Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
734 aurelien 1
package org.tela_botanica.client.util;
2 aperonnet 2
 
2558 aurelien 3
import java.text.NumberFormat;
4
import java.text.ParsePosition;
2392 aurelien 5
import java.util.ArrayList;
6
import java.util.Collections;
7
import java.util.Comparator;
1542 aurelien 8
import java.util.HashMap;
2606 aurelien 9
import java.util.Iterator;
2392 aurelien 10
import java.util.List;
1542 aurelien 11
import java.util.Map;
2392 aurelien 12
import java.util.Vector;
1542 aurelien 13
 
2626 aurelien 14
import org.tela_botanica.client.i18n.Msg;
1572 aurelien 15
import org.tela_botanica.client.modeles.objets.ChampEtendu;
989 aurelien 16
import org.tela_botanica.client.modeles.objets.Observation;
2606 aurelien 17
import org.tela_botanica.client.modeles.objets.ReferentielLocalite;
18
import org.tela_botanica.client.modeles.objets.ReferentielNom;
642 aurelien 19
 
2553 mathias 20
import com.google.gwt.dom.client.Element;
2602 aurelien 21
import com.google.gwt.http.client.Response;
1572 aurelien 22
import com.google.gwt.json.client.JSONArray;
1282 aurelien 23
import com.google.gwt.json.client.JSONObject;
2602 aurelien 24
import com.google.gwt.json.client.JSONParser;
1282 aurelien 25
import com.google.gwt.json.client.JSONString;
2602 aurelien 26
import com.google.gwt.json.client.JSONValue;
2553 mathias 27
import com.google.gwt.user.client.DOM;
28
import com.google.gwt.user.client.ui.RootPanel;
1282 aurelien 29
 
2 aperonnet 30
public class Util {
31
 
32
	public Util() {
33
	}
642 aurelien 34
 
1282 aurelien 35
	public static String getValeurJsonOuVide(JSONObject jo, String index) {
36
		return jsonNonNull(jo, index) ? ((JSONString)jo.get(index)).stringValue() : "";
37
	}
38
 
1572 aurelien 39
	public static Map<String, ChampEtendu> getMapValeursOuVide(JSONObject jo, String index) {
40
		Map<String, ChampEtendu> mapValeurs = new HashMap<String, ChampEtendu>();
41
		if(jo.get(index) != null && jo.get(index).isArray() != null) {
42
			JSONArray tabJo = jo.get(index).isArray();
43
			for (int i = 0; i < tabJo.size(); i++) {
44
				JSONObject champJson = tabJo.get(i).isObject();
45
				String cle = champJson.get("cle").isString().stringValue();
2392 aurelien 46
				String label = cle;
1572 aurelien 47
				String valeur = champJson.get("valeur").isString().stringValue();
48
				ChampEtendu champ = new ChampEtendu(cle, label, valeur);
49
				mapValeurs.put(cle, champ);
1542 aurelien 50
			}
1572 aurelien 51
 
1542 aurelien 52
		}
53
		return mapValeurs;
54
	}
55
 
1572 aurelien 56
	public static String convertirChampsEtendusEnChaineRequete(Map<String, ChampEtendu> map) {
57
		String json = "";
58
	    if (map != null && !map.isEmpty()) {
59
	    	JSONArray jsonArr = new JSONArray();
60
	    	int i = 0;
61
	        for (Map.Entry<String, ChampEtendu> entry: map.entrySet()) {
62
	        	jsonArr.set(i, convertirChampEtenduEnJson(entry.getValue()));
63
	        	i++;
64
	        }
65
	        json = jsonArr.toString();
66
	    }
67
	    return json;
1549 aurelien 68
	}
69
 
1572 aurelien 70
	public static JSONObject convertirChampEtenduEnJson(ChampEtendu champEtendu) {
71
		JSONObject jsonObj = new JSONObject();
72
		jsonObj.put("cle", new JSONString(champEtendu.getCle()));
73
		jsonObj.put("label", new JSONString(champEtendu.getLabel()));
74
		jsonObj.put("valeur", new JSONString(champEtendu.getValeur()));
75
        return jsonObj;
76
	}
77
 
1282 aurelien 78
	public static boolean jsonNonNull(JSONObject jo, String index) {
79
		return (jo != null &&
80
				jo.get(index) != null &&
81
				jo.get(index).isNull() == null
82
			   );
83
	}
84
 
642 aurelien 85
	public static String formaterLieu(Observation obs, String modeleLieu) {
86
 
87
		String lieuModele = modeleLieu;
88
 
2568 aurelien 89
		String localite = obs.getLocalite();
642 aurelien 90
		String lieuDit = obs.getLieudit();
91
		String station = obs.getStation();
92
 
2568 aurelien 93
		String lieulocaliteFormate = "";
642 aurelien 94
		String lieuDitFormate = "";
95
		String stationFormatee = "";
96
 
2568 aurelien 97
		if(localite != null && !localite.contains("000null") && !localite.trim().equals("")) {
642 aurelien 98
			String	idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/");
99
			if(idLoc != null && !idLoc.contains("000null") && !idLoc.trim().equals("")) {
100
 
101
				idLoc = idLoc.replaceAll("%","");
102
				idLoc = idLoc.replaceAll("\"","");
103
				idLoc = idLoc.replace('\\',' ');
104
				idLoc = idLoc.trim();
1332 aurelien 105
				if(idLoc.length() > 2) {
106
					idLoc = idLoc.substring(0,2);
107
				}
2568 aurelien 108
				lieulocaliteFormate += idLoc+" - ";
642 aurelien 109
			}
2568 aurelien 110
			lieulocaliteFormate += localite;
111
			lieuModele = lieuModele.replaceAll("IDLOCLOCALITE", lieulocaliteFormate);
642 aurelien 112
		} else {
113
 
2568 aurelien 114
			lieuModele = lieuModele.replaceAll("IDLOCLOCALITE,", lieulocaliteFormate);
642 aurelien 115
		}
116
 
117
		if(lieuDit != null && !lieuDit.contains("000null") && !lieuDit.trim().equals("")) {
118
			lieuDitFormate += lieuDit;
119
			lieuModele = lieuModele.replaceAll("LIEUDIT", lieuDitFormate);
120
		} else {
121
			lieuModele = lieuModele.replaceAll("LIEUDIT,", lieuDitFormate);
122
		}
123
 
124
		if(station != null && !station.contains("000null") && !station.trim().equals("")) {
125
			stationFormatee += station;
126
			lieuModele = lieuModele.replaceAll("STATION", stationFormatee);
127
		} else {
128
			lieuModele = lieuModele.replaceAll("STATION", stationFormatee);
129
		}
130
 
131
		lieuModele = lieuModele.trim();
132
		lieuModele = lieuModele.replaceAll(",$","");
133
		lieuModele = lieuModele.replaceAll(",^$",", ");
134
 
135
		return lieuModele;
136
	}
137
 
2568 aurelien 138
	public static String obtenirIdLocAPartirChaineLocalite(String localite) {
1542 aurelien 139
 
2558 aurelien 140
		String idLoc = "";
2568 aurelien 141
		String[] depCom = localite.split(" ");
2558 aurelien 142
		if(depCom.length > 1) {
143
			idLoc = depCom[1].replace('(', ' ');
1542 aurelien 144
		} else {
2558 aurelien 145
			idLoc = "";
1542 aurelien 146
		}
147
 
2558 aurelien 148
		idLoc = idLoc.replace(')', ' ');
149
		idLoc = idLoc.trim();
150
		idLoc = idLoc.replace('\\',' ');
151
		idLoc = idLoc.trim();
1542 aurelien 152
 
2558 aurelien 153
		return idLoc;
154
	}
155
 
156
	public static String formaterDepartement(String depAFormater) {
157
		String dep = "";
1542 aurelien 158
		try
159
		{
2558 aurelien 160
			int nDep = Integer.parseInt(depAFormater);
1542 aurelien 161
			if(nDep > 0 && nDep < 110) {
2558 aurelien 162
				dep = depAFormater ;
1542 aurelien 163
			}
164
 
2558 aurelien 165
			if(depAFormater.length() == 4) {
166
				dep = "0"+depAFormater;
1542 aurelien 167
			}
168
 
2558 aurelien 169
			dep = depAFormater.substring(0,2);
1542 aurelien 170
		}
171
		catch(NumberFormatException e)
172
		{
2558 aurelien 173
			// rien à faire
1542 aurelien 174
		}
175
 
2558 aurelien 176
		return dep;
1542 aurelien 177
	}
178
 
2558 aurelien 179
	public static String supprimerChaineIdLocalite(String chaineLocaliteComplete) {
180
		return chaineLocaliteComplete.replaceAll(" \\([a-zA-Z0-9]*\\)", "");
642 aurelien 181
	}
673 aurelien 182
 
962 aurelien 183
	public static String convertirChaineZoneGeoVersDepartement(String chaineZoneGeo) {
1672 aurelien 184
		return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("") && chaineZoneGeo.replaceAll("INSEE-C:", "").length() >= 2) ?
185
						chaineZoneGeo.replaceAll("INSEE-C:", "").substring(0, 2) :
186
						chaineZoneGeo;
962 aurelien 187
	}
188
 
189
	public static String convertirChaineZoneGeoVersCodeInsee(String chaineZoneGeo) {
190
		return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("")) ? chaineZoneGeo.replaceAll("INSEE-C:", ""): chaineZoneGeo;
191
	}
192
 
673 aurelien 193
	/***
194
	 * Fusionne les éléments d'un tableau en une chaîne
195
	 * @param delim : la chaîne de séparation
196
	 * @param args : la tableau
197
	 * @return la chaîne fusionnée
198
	 */
199
	public static String implode(String delim, String[] args){
200
		StringBuffer sb = new StringBuffer();
201
 
202
		int lgArgs = args.length;
203
 
204
		for(int i = 0; i < lgArgs; i++){
205
			if (i > 0) {
206
				sb.append(delim);
207
			}
208
 
209
			sb.append(args[i]);
210
		}
211
 
212
		return sb.toString();
213
	}
214
 
215
	public static boolean filtreValide(String[] filtre) {
216
 
217
		return (filtre.length == 2 &&
218
		filtre[0] != null &&
219
		!filtre[0].equals("") &&
220
		filtre[1] != null &&
221
		!filtre[1].equals(""));
222
	}
223
 
224
	public static String renvoyerMois(int numMois) {
225
 
2626 aurelien 226
		if(numMois >= 1 && numMois <= 12) {
227
			return Msg.get("mois-"+numMois);
228
		} else {
229
			return Msg.get("mois-inconnu") ;
673 aurelien 230
		}
231
	}
232
 
233
	public static String remplacerSautsDeligneMalEncodes(String chaineAvecSautsDeLignesMalEncodes) {
234
 
235
		String chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesMalEncodes.replace('\\','%');
236
		chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replaceAll("%n","%");
237
		chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replace('%','\n');
238
 
239
		return chaineAvecSautsDeLignesBienEncodes;
240
	}
241
 
242
	public static boolean verifierDateFormatCel(String dateAVerifier) {
243
 
244
		String dateRemplacee = remplacerSeparateursDateFormatCel(dateAVerifier);
245
		String[] tabDate = dateRemplacee.split("/");
246
 
247
		boolean retour = false;
248
 
249
		if(tabDate.length == 3) {
1282 aurelien 250
			//TODO: faire un parsing de date qui fonctionne mieux car
251
			// on peut saisir un 31 novembre par exemple
252
			// mais l'api date de java est mal gérée par gwt
673 aurelien 253
			try {
254
				int jour = Integer.parseInt(tabDate[0]);
255
				int mois = Integer.parseInt(tabDate[1]);
256
				int annee = Integer.parseInt(tabDate[2]);
257
 
1010 aurelien 258
				if(jour <= 31 && mois <= 12 && tabDate[2].length() == 4) {
673 aurelien 259
					retour = true;
260
				}
261
			} catch (Exception e) {
262
 
263
			}
264
		}
265
 
266
		return retour;
267
	}
268
 
269
	public static String remplacerSeparateursDateFormatCel(String date) {
270
 
271
		String dateRemplacee = date.replaceAll("-", "/");
272
 
273
	    return dateRemplacee;
274
	}
1572 aurelien 275
 
276
	public static boolean estZero(String s) {
277
		boolean estZero = false;
278
	    try {
279
	    	Double dou = Double.parseDouble(s);
280
	    	estZero = (dou == 0);
281
	    } catch(NumberFormatException e) {
282
 
283
	    }
284
	    return estZero;
285
	}
286
 
2558 aurelien 287
	public static boolean estUnNombre(String s) {
288
		//http://stackoverflow.com/questions/1102891/how-to-check-if-a-string-is-a-numeric-type-in-java
289
		try {
290
			double d = Double.parseDouble(s);
291
		} catch(NumberFormatException nfe) {
292
			return false;
293
		}
294
		return true;
295
	}
296
 
1572 aurelien 297
	public static String formaterNombre(String s) {
298
		s = s.indexOf(".") < 0 ? s : s.replaceAll("0*$", "").replaceAll("\\.$", "");
299
		return s;
300
	}
2276 mathias 301
 
302
	// Prend un nombre décimal avec le spéparateur spécifié et le tronque à n décimales
303
	public static String tronquerNombrePourAffichage(String nombre, int decimales, char separateur) {
304
		String retour = nombre;
305
		int posSep = nombre.indexOf(separateur);
306
		if (posSep >= 0) {
307
			int taille = posSep + decimales + 1;
308
			if (nombre.length() < taille) {
309
				taille = nombre.length();
310
			}
311
			retour = nombre.substring(0, taille);
312
		}
313
		return retour;
314
	}
315
 
316
	public static String tronquerNombrePourAffichage(String nombre, int decimales) {
317
		return tronquerNombrePourAffichage(nombre, decimales, '.');
318
	}
2392 aurelien 319
 
320
	// Adapté de http://www.programcreek.com/2011/03/java-method-for-spliting-a-camelcase-string/
321
	public static String formaterCleChampsEtenduPourAffichage(String s) {
322
		char[] cArray = s.toCharArray();
323
 
324
		Vector<Integer> al = new Vector<Integer>();
325
		al.add(0);
326
 
327
		// get all upper case letter index positions
328
		for (int i = 1; i < cArray.length; i++) {
329
			char c = cArray[i];
330
			//add more interested index beyond upper case letter
331
			if (c >= 65 && c <= 90) {
332
				al.add(i);
333
			}
334
		}
335
 
336
		Vector<String> strl = new Vector<String>();
337
 
338
		// this handles the all lower letter case
339
		if (al.size() == 1) {
340
			strl.add(s);
341
			return depilerChaineListee(strl, " ");
342
		}
343
 
344
 
345
		int prev = 0;
346
		int curr = 0;
347
		int begin = 0;
348
		for (int k = 1; k < al.size(); k++) {
349
 
350
			curr = al.get(k);
351
 
352
			if(curr == s.length() - 1){
353
 
354
			}
355
 
356
			if (curr == prev + 1 && curr != s.length() - 1) {
357
				prev = curr;
358
			} else if(curr == prev + 1 &&  curr == s.length() - 1){
359
				strl.add(s.substring(begin, curr+1));
360
			}else {
361
 
362
				strl.add(s.substring(prev, curr));
363
				prev = curr;
364
				begin = curr;
365
				if (k == al.size() - 1) {
366
					strl.add(s.substring(curr, s.length()));
367
				}
368
			}
369
		}
370
 
371
		return depilerChaineListee(strl, " ");
372
	}
373
 
374
	private static String depilerChaineListee(Vector<String> strl, String separateur) {
375
		String s = "";
376
		for(int i = 0; i < strl.size(); i++) {
377
			s += strl.get(i);
378
			if(i != strl.size() - 1) {
379
				s += separateur;
380
			}
381
		}
382
		return s;
383
	}
384
 
385
	public static Map<String, ChampEtendu> trierListeChampsEtendus(Map<String, ChampEtendu> listeChampsEtendus) {
386
		List<String> tmp = new ArrayList<String>(listeChampsEtendus.keySet());
387
		Collections.sort(tmp, new Comparator<String>() {
388
 
389
		    @Override
390
		    public int compare(String arg0, String arg1) {
391
		        return arg0.compareTo(arg1);
392
		    }
393
 
394
		});
395
		return listeChampsEtendus;
396
	}
2401 aurelien 397
 
398
	/**
399
	 * Solution issue de stackoverflow :
400
	 * http://stackoverflow.com/questions/1143951/what-is-the-simplest-way-to-convert-a-java-string-from-all-caps-words-separated
401
	 */
402
	public static String convertirEnChaMot(String s) {
403
		s = s.replaceAll("_", " ");
404
		s = s.replaceAll("-", " ");
405
		String[] parties = s.split(" ");
406
		String chaineChaMot = "";
407
		for (String partie : parties){
408
			chaineChaMot = chaineChaMot + convertirMotEnChaMot(partie);
409
		}
410
		return chaineChaMot;
411
	}
412
 
413
	protected static String convertirMotEnChaMot(String s) {
414
		return s.substring(0, 1).toUpperCase() +
415
	               s.substring(1).toLowerCase();
416
	}
2553 mathias 417
 
418
	public static void curseurAttente() {
419
	    RootPanel.getBodyElement().getStyle().setProperty("cursor", "wait");
420
	}
421
 
422
	public static void curseurParDefaut() {
423
		RootPanel.getBodyElement().getStyle().setProperty("cursor", "default");
424
	}
2602 aurelien 425
 
426
	public static Map<String, String> parserRetourReferentielPerso(Response response) {
427
		final Map<String, String> referentielData = new HashMap<String, String>();
428
		final JSONValue responseValue = JSONParser.parse(response.getText());
429
 
430
		JSONArray reponse = null;
431
 
432
		// si c'est un tableau
433
		if ((reponse = responseValue.isArray()) != null) {
434
 
435
			JSONString elementsRef;
436
			final int taillemax = reponse.size();
437
 
438
			for (int i = 0; i < taillemax; i++) {
439
				if ((elementsRef = reponse.get(i).isString()) != null) {
440
 
441
					String valeur = elementsRef.stringValue();
442
					referentielData.put(i+"", valeur);
443
 
444
				}
445
			}
446
		}
447
		return referentielData;
448
	}
2606 aurelien 449
 
450
	public static Map<String, ReferentielNom> parserRetourReferentielNomIndexeParNom(Response response) {
451
 
452
		final Map<String, ReferentielNom> referentielNomData ;
453
		final JSONValue responseValue = JSONParser.parse(response.getText());
454
		JSONArray reponse=null;
455
 
456
		// si c'est un tableau
457
		if ((reponse=responseValue.isArray()) != null) {
458
 
459
			JSONArray noms;
460
			final int taillemax = reponse.size();
461
 
462
			referentielNomData = new HashMap<String, ReferentielNom>(taillemax);
463
			for (int i = 0; i < taillemax; i++) {
464
				if ((noms=reponse.get(i).isArray()) != null) {
465
					String nom = ((JSONString) noms.get(0)).stringValue();
466
					String numeroNom = ((JSONString) noms.get(1)).stringValue();
467
					String statut= ((JSONString) noms.get(2)).stringValue();
468
					ReferentielNom nomScientifique = new ReferentielNom(nom, numeroNom, statut);
469
					// FIXME : et si le numero de nom n'est pas unique ? (cas de multirefrentiel....)
470
					referentielNomData.put(nomScientifique.getNom(),nomScientifique);
471
				}
472
			}
473
		} else {
474
			referentielNomData = new HashMap<String, ReferentielNom>(0);
475
		}
476
		return referentielNomData;
477
	}
478
 
479
	public static Map<String, String> convertirListeReferentielNomVersMap(Map<String, ReferentielNom> referentielNom) {
480
		Map<String, String> nomMap = new HashMap<String, String>();
481
		for (Iterator<String> it  = referentielNom.keySet().iterator(); it.hasNext();) {
482
			String cle = it.next();
483
			nomMap.put(cle, referentielNom.get(cle).getNom());
484
		}
485
		return nomMap;
486
	}
487
 
488
	public static Map<String, ReferentielLocalite> parserRetourReferentielLocaliteIndexeParNom(Response response) {
489
 
490
		final Map<String, ReferentielLocalite> referentielLocaliteData;
491
		final JSONValue responseValue = JSONParser.parse(response.getText());
492
		JSONArray reponse = null;
493
 
494
		// si c'est un tableau
495
		if ((reponse = responseValue.isArray()) != null) {
496
 
497
			JSONArray localites;
498
			final int taillemax = reponse.size();
499
 
500
			referentielLocaliteData = new HashMap<String, ReferentielLocalite>(taillemax);
501
 
502
			for (int i = 0; i < taillemax; i++) {
503
				if ((localites = reponse.get(i).isArray()) != null) {
504
					String localite = ((JSONString) localites.get(0)).stringValue();
505
					String codeLocalite  = ((JSONString) localites.get(1)).stringValue();
506
					ReferentielLocalite com = new ReferentielLocalite(localite, codeLocalite);
507
					referentielLocaliteData.put(com.getLocalite() + com.getCodeLocalite(), com);
508
				}
509
			}
510
		} else {
511
			referentielLocaliteData = new HashMap<String, ReferentielLocalite>(0);
512
		}
513
		return referentielLocaliteData;
514
	}
515
 
516
	public static Map<String, String> convertirListeReferentielLocaliteVersMap(Map<String, ReferentielLocalite> referentielLocalite) {
517
		Map<String, String> locMap = new HashMap<String, String>();
518
		for (Iterator<String> it  = referentielLocalite.keySet().iterator(); it.hasNext();) {
519
			String cle = it.next();
520
			locMap.put(cle, referentielLocalite.get(cle).getLocalite());
521
		}
522
		return locMap;
523
	}
2 aperonnet 524
}