Subversion Repositories eFlore/Applications.coel

Rev

Rev 1513 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
69 jpm 1
package org.tela_botanica.client.modeles;
2
 
570 jp_milcent 3
import java.util.HashMap;
4
 
1367 cyprien 5
import org.tela_botanica.client.Mediateur;
773 jpm 6
import org.tela_botanica.client.http.JsonRestRequestBuilder;
7
import org.tela_botanica.client.http.JsonRestRequestCallback;
69 jpm 8
import org.tela_botanica.client.interfaces.Rafraichissable;
1319 gduche 9
import org.tela_botanica.client.synchronisation.Reponse;
10
import org.tela_botanica.client.synchronisation.Sequenceur;
1292 cyprien 11
import org.tela_botanica.client.util.Debug;
299 gduche 12
import org.tela_botanica.client.util.UtilDAO;
69 jpm 13
 
14
import com.google.gwt.json.client.JSONArray;
1292 cyprien 15
import com.google.gwt.json.client.JSONBoolean;
16
import com.google.gwt.json.client.JSONNumber;
91 jpm 17
import com.google.gwt.json.client.JSONObject;
18
import com.google.gwt.json.client.JSONString;
69 jpm 19
import com.google.gwt.json.client.JSONValue;
20
 
21
public class ValeurListeAsyncDao {
570 jp_milcent 22
 
1292 cyprien 23
	private static HashMap<String, Object> ontologieCache = new HashMap<String, Object>();
24
 
268 jp_milcent 25
	private static final String SERVICE_NOM = "CoelValeurListe";
570 jp_milcent 26
	private Rafraichissable vueARafraichir = null;
1292 cyprien 27
	private int cptPage = 0;
1329 cyprien 28
	// FIXME : limiteJREST devrait être récupéré depuis un registre/dictionnaire
1292 cyprien 29
	private int limiteJREST = 150;
30
 
570 jp_milcent 31
	public ValeurListeAsyncDao(Rafraichissable vueCourante) {
32
		vueARafraichir = vueCourante;
1367 cyprien 33
		if (Mediateur.DEBUG) System.out.println("|| ValeurListeAsyncDao > vueARafraichir = "+vueARafraichir.getClass().toString());
268 jp_milcent 34
	}
35
 
1292 cyprien 36
	public static HashMap<String, Object> getOntologieCache() {
37
		return ontologieCache;
292 gduche 38
	}
39
 
1367 cyprien 40
	public void obtenirListe(Integer cle, Integer seqId) {
1319 gduche 41
		selectionner("id", cle, null, null, false, null, -1, -1, seqId);
1292 cyprien 42
	}
43
 
1367 cyprien 44
	public void obtenirListe(String type, String identifiantValeur, Integer seqId) {
1319 gduche 45
		selectionner(type, null, null, identifiantValeur, false, null, -1, -1, seqId);
1292 cyprien 46
	}
47
 
1367 cyprien 48
	public void obtenirListe(Integer cle, boolean pagination, String recherche, int start, int limit, Integer seqId) {
1319 gduche 49
		selectionner("nom", cle, null, null, pagination, recherche, start, limit, seqId);
1292 cyprien 50
	}
51
 
1319 gduche 52
	public void selectionner(String type, Integer cle, String abv, String idValeur, Integer seqId) {
53
		selectionner(type, cle, abv, idValeur, false, null, -1, -1, seqId);
1292 cyprien 54
	}
55
 
1329 cyprien 56
	/****************************************************************************************************
57
	 ** 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)
58
	/****************************************************************************************************
59
	 * Action :
60
	 * --------
61
	 * 		Récupère un nombre défini de Valeurs en s'aidant du nom partiel ou complet d'une valeur.
62
	 * 		Cette méthode gère deux types de sélection de données :
63
	 * 		- la sélection en cache (ontologieCache) --> pagination = FALSE
64
	 * 		- la sélection "au fur et à mesure" --> pagination = TRUE
65
	 *
66
	 * 		Gestion du cache :
67
	 * 		------------------
68
	 * 		- Le cache est utilisé si et seulement si 'pagination' est à FAUX car dans le cas où PAGINATION est
69
	 * 			à VRAI, les enregistrements sont chargés au fur et à mesure de la consultation des pages par
70
	 * 			l'utilisateur.
71
	 * 		- Si la taille de la liste chargée est supérieure au nombre maximum d'enregistrements retourné
72
	 * 		par le service JREST, alors on charge des blocs de valeurs jusqu'à ce que la totalité de la
73
	 * 		liste soit chargée.
74
	 *
75
	 * Description des paramètres :
76
	 * ----------------------------
77
	 *  @param 'type' est un paramètre directement destiné au service JREST. Il permet de définir le type
78
	 *  		de requête SQL à exécuter.
79
	 *  @param 	'cle' est l'identifiant de la liste de valeurs à récupérer (cas d'un noeud dans l'arbre).
80
	 *  @param 	'abv' sert pour la liste des régions. Il représente l'abréviation du nom d'un pays. Ce
81
	 *  		paramètre est concaténé à la clé pour former une clé particulière dont on se sert pour
82
	 *  		stocker la liste en cache.
83
	 *  @param	'idValeur' est l'identifiant de la valeur à récupérer (cas d'une feuille dans l'arbre).
84
	 *  @param	'pagination' est un booléen qui définit si la requête doit être paginée ou non.
85
	 *  @param	'recherche' est une chaîne de caractères représentant tout ou partie du nom d'un projet.
86
	 *  		Si la chaîne est vide, alors tous les projets sont recherchés.
1764 aurelien 87
	 *  		(la notion de projet a été supprimée)
88
	 *  		//TODO: pertinence de ce paramètre
1329 cyprien 89
	 *  @param	'start' et 'limit' sont les paramètres indispensables à la pagination. 'start'
90
	 *  		est le paramètre qui décrit le numéro du tuple de départ et 'limit' le nombre
91
	 *  		d'éléments à collecter.
92
	 *
93
	 *****************************************************************************************************/
1367 cyprien 94
	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) {
1329 cyprien 95
		/**
96
		 * La cleParent en Integer est insuffisante pour les liste valeurs comme Région qui on plusieurs
97
		 * sections sur leur liste (ex : on ne sélectionne que les régions FR.__ puis les régions ES.__ sur la liste 1078 ....
98
		 **/
1292 cyprien 99
		final String cleParentPourCache = cle + (abv == null ? "" : abv);
100
		final String cleParent = cle+"";
1038 gduche 101
 
1329 cyprien 102
		/** GESTION DU PARAMETRE 'recherche' **/
1292 cyprien 103
		String nom = "";
104
		if ( (recherche == null) || (recherche.equals("")) ) nom = "";
105
		else {
106
			nom = recherche+"%";
107
		}
108
 
1329 cyprien 109
		/** GESTION DU PARAMETRE 'abréviation' **/
1292 cyprien 110
		String abreviation = "";
111
		String paramAbv = "";
112
		if (type.equals("ab") || type.equals("abv")) {
113
			int positionPoint = abv.indexOf(".");
114
			if (positionPoint != -1) abreviation = abv.substring(0, positionPoint)+"%";
115
			else abreviation=abv+"%";
116
		}
117
		paramAbv = abreviation;
118
 
1329 cyprien 119
		/** GESTION DES PARAMETRES à transmettre au JREST **/
1292 cyprien 120
		String[] parametres = {type, cleParent, paramAbv, idValeur, nom};
121
		HashMap<String, String> restrictions = new HashMap<String, String>();
122
 
1329 cyprien 123
		/** GESTION DE LA REQUETE dans le cas d'une liste paginée **/
1292 cyprien 124
		if (pagination)	{
125
 
126
			restrictions.put("limit", String.valueOf(limit));
127
			restrictions.put("start", String.valueOf(start));
128
			restrictions.put("orderby", "cmlv_nom");
129
 
1329 cyprien 130
			/** CONSTRUCTION DE LA REQUETE **/
1292 cyprien 131
    		final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
1329 cyprien 132
 
133
    		/** ENVOI DE LA REQUETE **/
1292 cyprien 134
    		rb.envoyerRequete(null, new JsonRestRequestCallback()
135
    		{
1329 cyprien 136
    			/** RECEPTION DE LA REPONSE **/
1292 cyprien 137
    			public void surReponse(JSONValue responseValue)
1367 cyprien 138
    			{
1319 gduche 139
    				if (vueARafraichir instanceof Sequenceur)	{
1367 cyprien 140
    					if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste paginée, retour au sequenceur");
1319 gduche 141
    					Reponse reponse = new Reponse(responseValue, seqId);
142
    					vueARafraichir.rafraichir(reponse);
1329 cyprien 143
 
144
    				/** Dans le cas d'une liste paginée, vueARafraichir est un objet Proxy.
145
    				 * On retourne l'objet JSON au proxy afin que ce soit lui qui le traite **/
1319 gduche 146
    				} else {
1367 cyprien 147
    					if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste paginée, retour à "+vueARafraichir.getClass().toString());
1319 gduche 148
    					vueARafraichir.rafraichir(responseValue);
149
    				}
773 jpm 150
    			}
151
    		});
1292 cyprien 152
		}
1329 cyprien 153
		/** GESTION DE LA REQUETE dans le cas d'une liste NON paginée **/
1292 cyprien 154
		else
155
		{
1329 cyprien 156
			/** si start est supérieur à zéro, alors cela signifie que l'on doit charger une nouvelle page **/
1292 cyprien 157
			boolean nextPage = (start > 0);
158
 
1329 cyprien 159
			/** définition des contraintes sur la requête SQL **/
160
			if (nextPage) {
1292 cyprien 161
				restrictions.put("start", String.valueOf(start));
162
				restrictions.put("limit", String.valueOf(limit));
163
				restrictions.put("orderby", "cmlv_nom");
164
			}
1329 cyprien 165
			else {
1292 cyprien 166
				restrictions.put("orderby", "cmlv_nom");
167
			}
168
 
1329 cyprien 169
			/** 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 **/
170
			if (!nextPage && ontologieCache.containsKey(cleParentPourCache)) {
171
 
1367 cyprien 172
				/** on retourne à la vue la liste contenue dans le cache **/
173
				if (vueARafraichir instanceof Sequenceur)	{
174
					if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour au sequenceur");
175
					vueARafraichir = (Sequenceur) vueARafraichir;
176
					Reponse reponse = new Reponse(ontologieCache.get(cleParentPourCache), seqId);
177
					vueARafraichir.rafraichir(reponse);
178
				} else {
1369 cyprien 179
					if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour à "+vueARafraichir.getClass().toString());
1367 cyprien 180
					vueARafraichir.rafraichir(ontologieCache.get(cleParentPourCache));
181
				}
1329 cyprien 182
			}
183
			/** 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) **/
184
			else {
185
 
186
				/** CONSTRUCTION DE LA REQUETE **/
1292 cyprien 187
	    		final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
1329 cyprien 188
 
189
	    		/** ENVOI DE LA REQUETE **/
190
	    		rb.envoyerRequete(null, new JsonRestRequestCallback() {
191
 
192
	    			/** RECEPTION DE LA REPONSE **/
193
	    			public void surReponse(JSONValue responseValue) {
194
 
195
	    				/** Si la réponse n'est pas vide **/
196
	    				if (responseValue.isObject() != null) {
197
 
198
	    					/** Récupération des différents paramètres de la réponse JSON **/
1292 cyprien 199
							final JSONObject reponse = responseValue.isObject();
200
							JSONString listeId = reponse.get("id").isString();
201
							JSONArray listeValeurs = reponse.get("valeurs").isArray();
202
							JSONNumber nbElements = reponse.get("nbElements").isNumber();
203
							JSONBoolean getNextPage = reponse.get("getNextPage").isBoolean();
204
 
205
							/** Gestion de l'abreviation (pour la liste des régions) **/
206
							String abreviationStr = "";
207
							if (reponse.get("abreviation") != null) {
208
								abreviationStr = reponse.get("abreviation").isString().stringValue();
209
								int a = abreviationStr.indexOf("%", 1);
210
								abreviationStr = abreviationStr.substring(1, a);
211
							}
212
							else {
213
								abreviationStr = "";
214
							}
215
 
1329 cyprien 216
							/** Si l'on a bien reçu une liste de valeurs **/
1292 cyprien 217
							if (listeId != null)
218
							{
219
								/** Transformation du tableau JSON réponse en ValeurListe **/
220
								String id = listeId.stringValue();
221
								ValeurListe liste = new ValeurListe(new JSONString(id), abreviationStr, listeValeurs, nbElements);
222
 
223
								/** Si la liste existe deja en cache **/
224
								String identifiantCache = (abreviationStr=="") ? id : (id+abreviationStr);
225
								if (ontologieCache.get(id) != null)
226
								{
227
									/** Alors on concatène la liste existante avec celle qu'on vient de recevoir **/
228
									((ValeurListe)ontologieCache.get(identifiantCache)).concatenerListe(liste);
229
								}
230
								/** Sinon on l'insère simplement dans le cache **/
231
								else {
232
									ontologieCache.put(identifiantCache,liste);
233
								}
234
 
235
								/** Appel à la méthode qui gère le retour à l'appelant ou la suite du chargement **/
1319 gduche 236
								chargerListe(getNextPage.booleanValue(), type, liste.getId(), abv, idValeur, pagination, recherche, start, limit, seqId);
1292 cyprien 237
							}
238
	    				}
239
	    			}
240
	    		});
241
	    	}
242
		}
69 jpm 243
	}
1329 cyprien 244
 
245
	/********************************************************************************************************
246
	 * Action :
247
	 * --------
248
	 * 		Clotûre le chargement d'une liste de valeurs si le chargement est terminé, ou lance le chargement
249
	 * 		du prochain bloc de données si la liste n'est pas chargée en totalité.
250
	 *
251
	 * Paramètres :
252
	 * ------------
253
	 * @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
254
	 * @param Tous les autres paramètres sont les mêmes que pour la méthode 'selectionner'
255
	 *
256
	 *********************************************************************************************************/
257
	public void chargerListe(boolean nextPage, String type, Integer cle, String abv, String idValeur, boolean pagination, String recherche, int start, int nbElements, final Integer seqId) {
258
 
259
		/** Si nextpage est VRAI, alors cela signifie que l'on doit relancer une requete pour obtenir
260
		la page suivante **/
261
		if (nextPage) {
262
			cptPage++;
263
			selectionner(type, cle, abv, idValeur, pagination, recherche, cptPage*limiteJREST, limiteJREST, seqId);
264
		}
265
 
266
		/** Sinon cela signifie que le chargement de la liste est terminé et on peut
267
		la mettre en cache et retourner la réponse au demandeur **/
268
		else {
269
			// recupération de l'idenfiant de la liste
270
			String id = String.valueOf(cle);
271
 
272
			// gestion de l'abréviation pour la liste des régions
273
			String abreviationStr = "";
274
			if (abv != null) {
275
				abreviationStr = abv;
276
				int indexPoint = abreviationStr.indexOf(".", 0);
277
				abreviationStr = abreviationStr.substring(0, indexPoint);
278
				id = id+abreviationStr;
279
			}
280
 
281
			/** On retourne la liste à la vue **/
282
			if (ontologieCache.get(id) != null) {
283
				if (vueARafraichir instanceof Sequenceur)	{
1373 cyprien 284
					if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour au sequenceur (cptPage="+cptPage+")");
1329 cyprien 285
					vueARafraichir = (Sequenceur) vueARafraichir;
286
					Reponse reponse = new Reponse(ontologieCache.get(id), seqId);
287
					vueARafraichir.rafraichir(reponse);
288
				} else {
1369 cyprien 289
					if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour à "+vueARafraichir.getClass().toString());
1329 cyprien 290
					vueARafraichir.rafraichir(ontologieCache.get(id));
291
				}
292
			}
1373 cyprien 293
 
294
			// réinitialisation du compteur
295
			cptPage = 0;
1329 cyprien 296
		}
297
	}
1292 cyprien 298
}