| 21,12 → 21,10 |
|---|
| |
| private static HashMap<String, Object> ontologieCache = new HashMap<String, Object>(); |
| |
| private static HashMap<String, HashMap<Integer, Object>> pagedOntologieCache = new HashMap<String, HashMap<Integer, Object>>(); |
| |
| private static final String SERVICE_NOM = "CoelValeurListe"; |
| private Rafraichissable vueARafraichir = null; |
| private static ValeurListe tempListe = new ValeurListe(); |
| private int cptPage = 0; |
| // FIXME : limiteJREST devrait être récupéré depuis un registre/dictionnaire |
| private int limiteJREST = 150; |
| |
| public ValeurListeAsyncDao(Rafraichissable vueCourante) { |
| 36,45 → 34,6 |
|---|
| public static HashMap<String, Object> getOntologieCache() { |
| return ontologieCache; |
| } |
| |
| 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 la liste est plus grande |
| que la limite du JREST et 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 { |
| // on met en cache |
| String id = String.valueOf(cle); |
| |
| String abreviationStr = ""; |
| if (abv != null) { |
| abreviationStr = abv; |
| int indexPoint = abreviationStr.indexOf(".", 0); |
| abreviationStr = abreviationStr.substring(0, indexPoint); |
| id = id+abreviationStr; |
| } |
| |
| // réinitialiser le compteur |
| cptPage = 0; |
| |
| // et on met à jour le demandeur des données |
| if (ontologieCache.get(id) != null) { |
| if (vueARafraichir instanceof Sequenceur) { |
| vueARafraichir = (Sequenceur) vueARafraichir; |
| |
| Reponse reponse = new Reponse(ontologieCache.get(id), seqId); |
| vueARafraichir.rafraichir(reponse); |
| } else { |
| vueARafraichir.rafraichir(ontologieCache.get(id)); |
| } |
| } |
| } |
| } |
| |
| public void obtenirListe(Integer cle, Integer seqId) { |
| selectionner("id", cle, null, null, false, null, -1, -1, seqId); |
| 92,12 → 51,52 |
|---|
| 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 .... |
| |
| /** |
| * 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 { |
| 104,9 → 103,9 |
|---|
| 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)+"%"; |
| 114,10 → 113,11 |
|---|
| } |
| 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)); |
| 124,15 → 124,21 |
|---|
| 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() |
| { |
| @Override |
| /** RECEPTION DE LA REPONSE **/ |
| public void surReponse(JSONValue responseValue) |
| { |
| { |
| if (vueARafraichir instanceof 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 { |
| vueARafraichir.rafraichir(responseValue); |
| } |
| 139,44 → 145,44 |
|---|
| } |
| }); |
| } |
| /** 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); |
| |
| if (nextPage) |
| { |
| /** 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 |
| { |
| else { |
| restrictions.put("orderby", "cmlv_nom"); |
| } |
| |
| // si l'on est pas dans un processus de récupération d'une liste |
| // et si le cache contient déjà la liste recherchée |
| if (ontologieCache.containsKey(cleParentPourCache) && !nextPage) |
| { |
| //On est à la derniere page, on peu rafraichir |
| if (vueARafraichir instanceof Sequenceur) { |
| Reponse reponse = new Reponse(ontologieCache.get(cleParentPourCache), seqId); |
| vueARafraichir.rafraichir(reponse); |
| } else { |
| vueARafraichir.rafraichir(ontologieCache.get(cleParentPourCache)); |
| } |
| } |
| else |
| { |
| /** 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 **/ |
| 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); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() |
| { |
| @Override |
| public void surReponse(JSONValue responseValue) |
| { |
| if (responseValue.isObject() != null) |
| { |
| /** Récuperation des différents paramètres de la réponse JSON **/ |
| |
| /** 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(); |
| 194,7 → 200,7 |
|---|
| abreviationStr = ""; |
| } |
| |
| /** si l'on a bien reçu une liste de valeurs **/ |
| /** Si l'on a bien reçu une liste de valeurs **/ |
| if (listeId != null) |
| { |
| /** Transformation du tableau JSON réponse en ValeurListe **/ |
| 222,4 → 228,56 |
|---|
| } |
| } |
| } |
| |
| /******************************************************************************************************** |
| * 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; |
| } |
| |
| // réinitialisation du compteur |
| cptPage = 0; |
| |
| /** On retourne la liste à la vue **/ |
| if (ontologieCache.get(id) != null) { |
| if (vueARafraichir instanceof Sequenceur) { |
| vueARafraichir = (Sequenceur) vueARafraichir; |
| Reponse reponse = new Reponse(ontologieCache.get(id), seqId); |
| vueARafraichir.rafraichir(reponse); |
| } else { |
| vueARafraichir.rafraichir(ontologieCache.get(id)); |
| } |
| } |
| } |
| } |
| } |