Subversion Repositories eFlore/Applications.coel

Rev

Rev 1373 | 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.Mediateur;
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.synchronisation.Reponse;
import org.tela_botanica.client.synchronisation.Sequenceur;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.UtilDAO;

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;

public class ValeurListeAsyncDao {
        
        private static HashMap<String, Object> ontologieCache = new HashMap<String, Object>();
        
        private static final String SERVICE_NOM = "CoelValeurListe";
        private Rafraichissable vueARafraichir = null;
        private int cptPage = 0;
        // FIXME : limiteJREST devrait être récupéré depuis un registre/dictionnaire
        private int limiteJREST = 150;

        public ValeurListeAsyncDao(Rafraichissable vueCourante) {
                vueARafraichir = vueCourante;
                if (Mediateur.DEBUG) System.out.println("|| ValeurListeAsyncDao > vueARafraichir = "+vueARafraichir.getClass().toString());
        }
        
        public static HashMap<String, Object> getOntologieCache() {
                return ontologieCache;
        }
        
        public void obtenirListe(Integer cle, Integer seqId) {
                selectionner("id", cle, null, null, false, null, -1, -1, seqId);
        }
        
        public void obtenirListe(String type, String identifiantValeur, Integer seqId) {
                selectionner(type, null, null, identifiantValeur, false, null, -1, -1, seqId);
        }
        
        public void obtenirListe(Integer cle, boolean pagination, String recherche, int start, int limit, Integer seqId) {
                selectionner("nom", cle, null, null, pagination, recherche, start, limit, seqId);
        }
        
        public void selectionner(String type, Integer cle, String abv, String idValeur, Integer seqId) {
                selectionner(type, cle, abv, idValeur, false, null, -1, -1, seqId);
        }

        /****************************************************************************************************
         ** selectionner(final String type, final Integer cle, final String abv, final String idValeur, final boolean pagination, final String recherche, final int start, final int limit)
        /****************************************************************************************************
         * Action :
         * --------
         *              Récupère un nombre défini de Valeurs en s'aidant du nom partiel ou complet d'une valeur. 
         *              Cette méthode gère deux types de sélection de données :
         *              - la sélection en cache (ontologieCache) --> pagination = FALSE
         *              - la sélection "au fur et à mesure" --> pagination = TRUE
         * 
         *              Gestion du cache :
         *              ------------------
         *              - Le cache est utilisé si et seulement si 'pagination' est à FAUX car dans le cas où PAGINATION est
         *                      à VRAI, les enregistrements sont chargés au fur et à mesure de la consultation des pages par
         *                      l'utilisateur.
         *              - Si la taille de la liste chargée est supérieure au nombre maximum d'enregistrements retourné
         *              par le service JREST, alors on charge des blocs de valeurs jusqu'à ce que la totalité de la
         *              liste soit chargée.
         * 
         * Description des paramètres :
         * ----------------------------
         *  @param 'type' est un paramètre directement destiné au service JREST. Il permet de définir le type
         *              de requête SQL à exécuter.
         *  @param      'cle' est l'identifiant de la liste de valeurs à récupérer (cas d'un noeud dans l'arbre).
         *  @param      'abv' sert pour la liste des régions. Il représente l'abréviation du nom d'un pays. Ce
         *              paramètre est concaténé à la clé pour former une clé particulière dont on se sert pour
         *              stocker la liste en cache.
         *  @param      'idValeur' est l'identifiant de la valeur à récupérer (cas d'une feuille dans l'arbre).
         *  @param      'pagination' est un booléen qui définit si la requête doit être paginée ou non.
         *  @param      'recherche' est une chaîne de caractères représentant tout ou partie du nom d'un projet.
         *              Si la chaîne est vide, alors tous les projets sont recherchés.
         *  @param      'start' et 'limit' sont les paramètres indispensables à la pagination. 'start'
         *              est le paramètre qui décrit le numéro du tuple de départ et 'limit' le nombre
         *              d'éléments à collecter.
         *  
         *****************************************************************************************************/
        public void selectionner(final String type, final Integer cle, final String abv, final String idValeur, final boolean pagination, final String recherche, final int start, final int limit, final Integer seqId) {              
                /**
                 * La cleParent en Integer est insuffisante pour les liste valeurs comme Région qui on plusieurs 
                 * sections sur leur liste (ex : on ne sélectionne que les régions FR.__ puis les régions ES.__ sur la liste 1078 ....
                 **/
                final String cleParentPourCache = cle + (abv == null ? "" : abv);
                final String cleParent = cle+"";
                
                /** GESTION DU PARAMETRE 'recherche' **/
                String nom = "";
                if ( (recherche == null) || (recherche.equals("")) ) nom = "";
                else {
                        nom = recherche+"%";
                }

                /** GESTION DU PARAMETRE 'abréviation' **/
                String abreviation = "";
                String paramAbv = "";
                if (type.equals("ab") || type.equals("abv")) {
                        int positionPoint = abv.indexOf(".");
                        if (positionPoint != -1) abreviation = abv.substring(0, positionPoint)+"%";
                        else abreviation=abv+"%";
                }
                paramAbv = abreviation;

                /** GESTION DES PARAMETRES à transmettre au JREST **/
                String[] parametres = {type, cleParent, paramAbv, idValeur, nom};
                HashMap<String, String> restrictions = new HashMap<String, String>();

                /** GESTION DE LA REQUETE dans le cas d'une liste paginée **/
                if (pagination) {

                        restrictions.put("limit", String.valueOf(limit));
                        restrictions.put("start", String.valueOf(start));
                        restrictions.put("orderby", "cmlv_nom");
                        
                        /** CONSTRUCTION DE LA REQUETE **/
                final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
                
                /** ENVOI DE LA REQUETE **/
                rb.envoyerRequete(null, new JsonRestRequestCallback()
                {
                        /** RECEPTION DE LA REPONSE **/
                        public void surReponse(JSONValue responseValue)
                        {                               
                                if (vueARafraichir instanceof Sequenceur)       {
                                        if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste paginée, retour au sequenceur");
                                        Reponse reponse = new Reponse(responseValue, seqId);
                                        vueARafraichir.rafraichir(reponse);
                                        
                                /** Dans le cas d'une liste paginée, vueARafraichir est un objet Proxy.
                                 * On retourne l'objet JSON au proxy afin que ce soit lui qui le traite **/
                                } else {
                                        if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste paginée, retour à "+vueARafraichir.getClass().toString());
                                        vueARafraichir.rafraichir(responseValue);
                                }
                        }
                });
                }
                /** GESTION DE LA REQUETE dans le cas d'une liste NON paginée **/
                else
                {
                        /** si start est supérieur à zéro, alors cela signifie que l'on doit charger une nouvelle page **/
                        boolean nextPage = (start > 0);
                        
                        /** définition des contraintes sur la requête SQL **/
                        if (nextPage) {
                                restrictions.put("start", String.valueOf(start));
                                restrictions.put("limit", String.valueOf(limit));
                                restrictions.put("orderby", "cmlv_nom");
                        }
                        else {
                                restrictions.put("orderby", "cmlv_nom");
                        }
                        
                        /** Si l'on est pas dans un processus de récupération d'une liste, alors si le cache contient déjà la liste recherchée **/
                        if (!nextPage && ontologieCache.containsKey(cleParentPourCache)) {
                                        
                                /** on retourne à la vue la liste contenue dans le cache **/                           
                                if (vueARafraichir instanceof Sequenceur)       {
                                        if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour au sequenceur");
                                        vueARafraichir = (Sequenceur) vueARafraichir;
                                        Reponse reponse = new Reponse(ontologieCache.get(cleParentPourCache), seqId);
                                        vueARafraichir.rafraichir(reponse);
                                } else {
                                        if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour à "+vueARafraichir.getClass().toString());
                                        vueARafraichir.rafraichir(ontologieCache.get(cleParentPourCache));
                                }
                        }
                        /** Si l'on est en train de récupérer une liste (c-a-d que l'on est en train de charger des blocs de données afin de récupérer totalement une liste) **/
                        else {
                                
                                /** CONSTRUCTION DE LA REQUETE **/
                        final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
                        
                        /** ENVOI DE LA REQUETE **/
                        rb.envoyerRequete(null, new JsonRestRequestCallback() {
                                
                                /** RECEPTION DE LA REPONSE **/
                                public void surReponse(JSONValue responseValue) {         
                                        
                                        /** Si la réponse n'est pas vide **/
                                        if (responseValue.isObject() != null) {
                                                
                                                /** Récupération des différents paramètres de la réponse JSON **/
                                                        final JSONObject reponse = responseValue.isObject();
                                                        JSONString listeId = reponse.get("id").isString();
                                                        JSONArray listeValeurs = reponse.get("valeurs").isArray();
                                                        JSONNumber nbElements = reponse.get("nbElements").isNumber();
                                                        JSONBoolean getNextPage = reponse.get("getNextPage").isBoolean();
                                                        
                                                        /** Gestion de l'abreviation (pour la liste des régions) **/
                                                        String abreviationStr = "";
                                                        if (reponse.get("abreviation") != null) {
                                                                abreviationStr = reponse.get("abreviation").isString().stringValue();
                                                                int a = abreviationStr.indexOf("%", 1);
                                                                abreviationStr = abreviationStr.substring(1, a);
                                                        }
                                                        else {
                                                                abreviationStr = "";
                                                        }

                                                        /** Si l'on a bien reçu une liste de valeurs **/
                                                        if (listeId != null)
                                                        {
                                                                /** Transformation du tableau JSON réponse en ValeurListe **/
                                                                String id = listeId.stringValue();
                                                                ValeurListe liste = new ValeurListe(new JSONString(id), abreviationStr, listeValeurs, nbElements);

                                                                /** Si la liste existe deja en cache **/
                                                                String identifiantCache = (abreviationStr=="") ? id : (id+abreviationStr);
                                                                if (ontologieCache.get(id) != null)
                                                                {
                                                                        /** Alors on concatène la liste existante avec celle qu'on vient de recevoir **/
                                                                        ((ValeurListe)ontologieCache.get(identifiantCache)).concatenerListe(liste);
                                                                }
                                                                /** Sinon on l'insère simplement dans le cache **/
                                                                else {
                                                                        ontologieCache.put(identifiantCache,liste);
                                                                }

                                                                /** Appel à la méthode qui gère le retour à l'appelant ou la suite du chargement **/
                                                                chargerListe(getNextPage.booleanValue(), type, liste.getId(), abv, idValeur, pagination, recherche, start, limit, seqId);
                                                        }
                                        }
                                }
                        });
                }
                }
        }
        
        /********************************************************************************************************
         * Action :
         * --------
         *              Clotûre le chargement d'une liste de valeurs si le chargement est terminé, ou lance le chargement
         *              du prochain bloc de données si la liste n'est pas chargée en totalité. 
         * 
         * Paramètres :
         * ------------
         * @param nextPage : est VRAI s'il faut faut continuer de charger la liste car elle n'est pas entièrement chargée et FAUX sinon
         * @param Tous les autres paramètres sont les mêmes que pour la méthode 'selectionner'
         * 
         *********************************************************************************************************/
        public void chargerListe(boolean nextPage, String type, Integer cle, String abv, String idValeur, boolean pagination, String recherche, int start, int nbElements, final Integer seqId) {
                
                /** Si nextpage est VRAI, alors cela signifie que l'on doit relancer une requete pour obtenir
                la page suivante **/
                if (nextPage) {
                        cptPage++;
                        selectionner(type, cle, abv, idValeur, pagination, recherche, cptPage*limiteJREST, limiteJREST, seqId);
                }
                
                /** Sinon cela signifie que le chargement de la liste est terminé et on peut
                la mettre en cache et retourner la réponse au demandeur **/
                else {
                        // recupération de l'idenfiant de la liste
                        String id = String.valueOf(cle);
                        
                        // gestion de l'abréviation pour la liste des régions
                        String abreviationStr = "";
                        if (abv != null) {
                                abreviationStr = abv;
                                int indexPoint = abreviationStr.indexOf(".", 0);
                                abreviationStr = abreviationStr.substring(0, indexPoint);
                                id = id+abreviationStr; 
                        }

                        /** On retourne la liste à la vue **/          
                        if (ontologieCache.get(id) != null) {
                                if (vueARafraichir instanceof Sequenceur)       {
                                        if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour au sequenceur (cptPage="+cptPage+")");
                                        vueARafraichir = (Sequenceur) vueARafraichir;
                                        Reponse reponse = new Reponse(ontologieCache.get(id), seqId);
                                        vueARafraichir.rafraichir(reponse);
                                } else {
                                        if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour à "+vueARafraichir.getClass().toString());
                                        vueARafraichir.rafraichir(ontologieCache.get(id));
                                }
                        }
                        
                        // réinitialisation du compteur
                        cptPage = 0;
                }
        }       
}