19,12 → 19,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) { |
34,38 → 32,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) { |
/** 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); |
} |
/** 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) { |
vueARafraichir.rafraichir(ontologieCache.get(id)); |
} |
} |
} |
|
public void obtenirListe(Integer cle) { |
selectionner("id", cle, null, null, false, null, -1, -1); |
81,15 → 47,54 |
|
public void selectionner(String type, Integer cle, String abv, String idValeur) { |
selectionner(type, cle, abv, idValeur, false, null, -1, -1); |
} |
|
} |
|
/**************************************************************************************************** |
** 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) { |
|
// 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 { |
96,9 → 101,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)+"%"; |
106,10 → 111,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)); |
116,48 → 122,59 |
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) |
{ |
{ |
/** 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 **/ |
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); |
|
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) |
{ |
/** 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)); |
} |
else |
{ |
} |
/** 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(); |
175,7 → 192,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 **/ |
203,4 → 220,50 |
} |
} |
} |
|
/******************************************************************************************************** |
* 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) { |
|
/** 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); |
} |
|
/** 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) { |
vueARafraichir.rafraichir(ontologieCache.get(id)); |
} |
} |
} |
} |