Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.util;

import java.text.NumberFormat;

import java.text.ParsePosition;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import org.tela_botanica.client.modeles.objets.ChampEtendu;

import org.tela_botanica.client.modeles.objets.Observation;

import org.tela_botanica.client.modeles.objets.ReferentielLocalite;

import org.tela_botanica.client.modeles.objets.ReferentielNom;

import com.google.gwt.dom.client.Element;

import com.google.gwt.http.client.Response;

import com.google.gwt.json.client.JSONArray;

import com.google.gwt.json.client.JSONObject;

import com.google.gwt.json.client.JSONParser;

import com.google.gwt.json.client.JSONString;

import com.google.gwt.json.client.JSONValue;

import com.google.gwt.user.client.DOM;

import com.google.gwt.user.client.ui.RootPanel;

public class Util {

	public Util() {

	}

	public static String getValeurJsonOuVide(JSONObject jo, String index) {

		return jsonNonNull(jo, index) ? ((JSONString)jo.get(index)).stringValue() : "";

	}

	public static Map<String, ChampEtendu> getMapValeursOuVide(JSONObject jo, String index) {

		Map<String, ChampEtendu> mapValeurs = new HashMap<String, ChampEtendu>();

		if(jo.get(index) != null && jo.get(index).isArray() != null) {

			JSONArray tabJo = jo.get(index).isArray();

			for (int i = 0; i < tabJo.size(); i++) {

				JSONObject champJson = tabJo.get(i).isObject();

				String cle = champJson.get("cle").isString().stringValue();

				String label = cle;

				String valeur = champJson.get("valeur").isString().stringValue();

				ChampEtendu champ = new ChampEtendu(cle, label, valeur);

				mapValeurs.put(cle, champ);

			}

		}

		return mapValeurs;

	}

	public static String convertirChampsEtendusEnChaineRequete(Map<String, ChampEtendu> map) {

		String json = "";

	    if (map != null && !map.isEmpty()) {

	    	JSONArray jsonArr = new JSONArray();

	    	int i = 0;

	        for (Map.Entry<String, ChampEtendu> entry: map.entrySet()) {

	        	jsonArr.set(i, convertirChampEtenduEnJson(entry.getValue()));

	        	i++;

	        }

	        json = jsonArr.toString();

	    }

	    return json;

	}

	public static JSONObject convertirChampEtenduEnJson(ChampEtendu champEtendu) {

		JSONObject jsonObj = new JSONObject();

		jsonObj.put("cle", new JSONString(champEtendu.getCle()));

		jsonObj.put("label", new JSONString(champEtendu.getLabel()));

		jsonObj.put("valeur", new JSONString(champEtendu.getValeur()));

        return jsonObj;

	}

	public static boolean jsonNonNull(JSONObject jo, String index) {

		return (jo != null &&

				jo.get(index) != null &&

				jo.get(index).isNull() == null

			   );

	}

	public static String formaterLieu(Observation obs, String modeleLieu) {

		String lieuModele = modeleLieu;

		String localite = obs.getLocalite();

		String lieuDit = obs.getLieudit();

		String station = obs.getStation();

		String lieulocaliteFormate = "";

		String lieuDitFormate = "";

		String stationFormatee = "";

		if(localite != null && !localite.contains("000null") && !localite.trim().equals("")) {

			String	idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/");

			if(idLoc != null && !idLoc.contains("000null") && !idLoc.trim().equals("")) {

				idLoc = idLoc.replaceAll("%","");

				idLoc = idLoc.replaceAll("\"","");

				idLoc = idLoc.replace('\\',' ');

				idLoc = idLoc.trim();

				if(idLoc.length() > 2) {

					idLoc = idLoc.substring(0,2);

				}

				lieulocaliteFormate += idLoc+" - ";

			}

			lieulocaliteFormate += localite;

			lieuModele = lieuModele.replaceAll("IDLOCLOCALITE", lieulocaliteFormate);

		} else {

			lieuModele = lieuModele.replaceAll("IDLOCLOCALITE,", lieulocaliteFormate);

		}

		if(lieuDit != null && !lieuDit.contains("000null") && !lieuDit.trim().equals("")) {

			lieuDitFormate += lieuDit;

			lieuModele = lieuModele.replaceAll("LIEUDIT", lieuDitFormate);

		} else {

			lieuModele = lieuModele.replaceAll("LIEUDIT,", lieuDitFormate);

		}

		if(station != null && !station.contains("000null") && !station.trim().equals("")) {

			stationFormatee += station;

			lieuModele = lieuModele.replaceAll("STATION", stationFormatee);

		} else {

			lieuModele = lieuModele.replaceAll("STATION", stationFormatee);

		}

		lieuModele = lieuModele.trim();

		lieuModele = lieuModele.replaceAll(",$","");

		lieuModele = lieuModele.replaceAll(",^$",", ");

		return lieuModele;

	}

	public static String obtenirIdLocAPartirChaineLocalite(String localite) {

		String idLoc = "";

		String[] depCom = localite.split(" ");

		if(depCom.length > 1) {

			idLoc = depCom[1].replace('(', ' ');

		} else {

			idLoc = "";

		}

		idLoc = idLoc.replace(')', ' ');

		idLoc = idLoc.trim();

		idLoc = idLoc.replace('\\',' ');

		idLoc = idLoc.trim();

		return idLoc;

	}

	public static String formaterDepartement(String depAFormater) {

		String dep = "";

		try

		{

			int nDep = Integer.parseInt(depAFormater);

			if(nDep > 0 && nDep < 110) {

				dep = depAFormater ;

			}

			if(depAFormater.length() == 4) {

				dep = "0"+depAFormater;

			}

			dep = depAFormater.substring(0,2);

		}

		catch(NumberFormatException e)

		{

			// rien à faire

		}

		return dep;

	}

	public static String supprimerChaineIdLocalite(String chaineLocaliteComplete) {

		return chaineLocaliteComplete.replaceAll(" \\([a-zA-Z0-9]*\\)", "");

	}

	public static String convertirChaineZoneGeoVersDepartement(String chaineZoneGeo) {

		return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("") && chaineZoneGeo.replaceAll("INSEE-C:", "").length() >= 2) ?

						chaineZoneGeo.replaceAll("INSEE-C:", "").substring(0, 2) :

						chaineZoneGeo;

	}

	public static String convertirChaineZoneGeoVersCodeInsee(String chaineZoneGeo) {

		return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("")) ? chaineZoneGeo.replaceAll("INSEE-C:", ""): chaineZoneGeo;

	}

	/***

	 * Fusionne les éléments d'un tableau en une chaîne

	 * @param delim : la chaîne de séparation

	 * @param args : la tableau

	 * @return la chaîne fusionnée

	 */

	public static String implode(String delim, String[] args){

		StringBuffer sb = new StringBuffer();

		int lgArgs = args.length;

		for(int i = 0; i < lgArgs; i++){

			if (i > 0) {

				sb.append(delim);

			}

			sb.append(args[i]);

		}

		return sb.toString();

	}

	public static boolean filtreValide(String[] filtre) {

		return (filtre.length == 2 &&

		filtre[0] != null &&

		!filtre[0].equals("") &&

		filtre[1] != null &&

		!filtre[1].equals(""));

	}

	public static String renvoyerMois(int numMois) {

		switch (numMois) {

		case 1:

			return "janvier" ;

		case 2:

			return "fevrier" ;

		case 3:

			return "mars" ;

		case 4:

			return "avril" ;

		case 5:

			return "mai" ;

		case 6:

			return "juin" ;

		case 7:

			return "juillet" ;

		case 8:

			return "août" ;

		case 9:

			return "septembre" ;

		case 10:

			return "octobre" ;

		case 11:

			return "novembre" ;

		case 12:

			return "décembre" ;

		default:

			return "Inconnu" ;

		}

	}

	public static String remplacerSautsDeligneMalEncodes(String chaineAvecSautsDeLignesMalEncodes) {

		String chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesMalEncodes.replace('\\','%');

		chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replaceAll("%n","%");

		chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replace('%','\n');

		return chaineAvecSautsDeLignesBienEncodes;

	}

	public static boolean verifierDateFormatCel(String dateAVerifier) {

		String dateRemplacee = remplacerSeparateursDateFormatCel(dateAVerifier);

		String[] tabDate = dateRemplacee.split("/");

		boolean retour = false;

		if(tabDate.length == 3) {

			//TODO: faire un parsing de date qui fonctionne mieux car

			// on peut saisir un 31 novembre par exemple

			// mais l'api date de java est mal gérée par gwt

			try {

				int jour = Integer.parseInt(tabDate[0]);

				int mois = Integer.parseInt(tabDate[1]);

				int annee = Integer.parseInt(tabDate[2]);

				if(jour <= 31 && mois <= 12 && tabDate[2].length() == 4) {

					retour = true;

				}

			} catch (Exception e) {

			}

		}

		return retour;

	}

	public static String remplacerSeparateursDateFormatCel(String date) {

		String dateRemplacee = date.replaceAll("-", "/");

	    return dateRemplacee;

	}

	public static boolean estZero(String s) {

		boolean estZero = false;

	    try {

	    	Double dou = Double.parseDouble(s);

	    	estZero = (dou == 0);

	    } catch(NumberFormatException e) {

	    }

	    return estZero;

	}

	public static boolean estUnNombre(String s) {

		//http://stackoverflow.com/questions/1102891/how-to-check-if-a-string-is-a-numeric-type-in-java

		try {

			double d = Double.parseDouble(s);

		} catch(NumberFormatException nfe) {

			return false;

		}

		return true;

	}

	public static String formaterNombre(String s) {

		s = s.indexOf(".") < 0 ? s : s.replaceAll("0*$", "").replaceAll("\\.$", "");

		return s;

	}

	// Prend un nombre décimal avec le spéparateur spécifié et le tronque à n décimales

	public static String tronquerNombrePourAffichage(String nombre, int decimales, char separateur) {

		String retour = nombre;

		int posSep = nombre.indexOf(separateur);

		if (posSep >= 0) {

			int taille = posSep + decimales + 1;

			if (nombre.length() < taille) {

				taille = nombre.length();

			}

			retour = nombre.substring(0, taille);

		}

		return retour;

	}

	public static String tronquerNombrePourAffichage(String nombre, int decimales) {

		return tronquerNombrePourAffichage(nombre, decimales, '.');

	}

	// Adapté de http://www.programcreek.com/2011/03/java-method-for-spliting-a-camelcase-string/

	public static String formaterCleChampsEtenduPourAffichage(String s) {

		char[] cArray = s.toCharArray();

		Vector<Integer> al = new Vector<Integer>();

		al.add(0);

		// get all upper case letter index positions

		for (int i = 1; i < cArray.length; i++) {

			char c = cArray[i];

			//add more interested index beyond upper case letter

			if (c >= 65 && c <= 90) {

				al.add(i);

			}

		}

		Vector<String> strl = new Vector<String>();

		// this handles the all lower letter case

		if (al.size() == 1) {

			strl.add(s);

			return depilerChaineListee(strl, " ");

		}

		int prev = 0;

		int curr = 0;

		int begin = 0;

		for (int k = 1; k < al.size(); k++) {

			curr = al.get(k);

			if(curr == s.length() - 1){

			}

			if (curr == prev + 1 && curr != s.length() - 1) {

				prev = curr;

			} else if(curr == prev + 1 &&  curr == s.length() - 1){

				strl.add(s.substring(begin, curr+1));

			}else {

				strl.add(s.substring(prev, curr));

				prev = curr;

				begin = curr;

				if (k == al.size() - 1) {

					strl.add(s.substring(curr, s.length()));

				}

			}

		}

		return depilerChaineListee(strl, " ");

	}

	private static String depilerChaineListee(Vector<String> strl, String separateur) {

		String s = "";

		for(int i = 0; i < strl.size(); i++) {

			s += strl.get(i);

			if(i != strl.size() - 1) {

				s += separateur;

			}

		}

		return s;

	}

	public static Map<String, ChampEtendu> trierListeChampsEtendus(Map<String, ChampEtendu> listeChampsEtendus) {

		List<String> tmp = new ArrayList<String>(listeChampsEtendus.keySet());

		Collections.sort(tmp, new Comparator<String>() {

		    @Override

		    public int compare(String arg0, String arg1) {

		        return arg0.compareTo(arg1);

		    }

		});

		return listeChampsEtendus;

	}

	/**

	 * Solution issue de stackoverflow :

	 * http://stackoverflow.com/questions/1143951/what-is-the-simplest-way-to-convert-a-java-string-from-all-caps-words-separated

	 */

	public static String convertirEnChaMot(String s) {

		s = s.replaceAll("_", " ");

		s = s.replaceAll("-", " ");

		String[] parties = s.split(" ");

		String chaineChaMot = "";

		for (String partie : parties){

			chaineChaMot = chaineChaMot + convertirMotEnChaMot(partie);

		}

		return chaineChaMot;

	}

	protected static String convertirMotEnChaMot(String s) {

		return s.substring(0, 1).toUpperCase() +

	               s.substring(1).toLowerCase();

	}

	public static void curseurAttente() {

	    RootPanel.getBodyElement().getStyle().setProperty("cursor", "wait");

	}

	public static void curseurParDefaut() {

		RootPanel.getBodyElement().getStyle().setProperty("cursor", "default");

	}

	public static Map<String, String> parserRetourReferentielPerso(Response response) {

		final Map<String, String> referentielData = new HashMap<String, String>();

		final JSONValue responseValue = JSONParser.parse(response.getText());

		JSONArray reponse = null;

		// si c'est un tableau

		if ((reponse = responseValue.isArray()) != null) {

			JSONString elementsRef;

			final int taillemax = reponse.size();

			for (int i = 0; i < taillemax; i++) {

				if ((elementsRef = reponse.get(i).isString()) != null) {

					String valeur = elementsRef.stringValue();

					referentielData.put(i+"", valeur);

				}

			}

		}

		return referentielData;

	}

	public static Map<String, ReferentielNom> parserRetourReferentielNomIndexeParNom(Response response) {

		final Map<String, ReferentielNom> referentielNomData ;

		final JSONValue responseValue = JSONParser.parse(response.getText());

		JSONArray reponse=null;

		// si c'est un tableau

		if ((reponse=responseValue.isArray()) != null) {

			JSONArray noms;

			final int taillemax = reponse.size();

			referentielNomData = new HashMap<String, ReferentielNom>(taillemax);

			for (int i = 0; i < taillemax; i++) {

				if ((noms=reponse.get(i).isArray()) != null) {

					String nom = ((JSONString) noms.get(0)).stringValue();

					String numeroNom = ((JSONString) noms.get(1)).stringValue();

					String statut= ((JSONString) noms.get(2)).stringValue();

					ReferentielNom nomScientifique = new ReferentielNom(nom, numeroNom, statut);

					// FIXME : et si le numero de nom n'est pas unique ? (cas de multirefrentiel....)

					referentielNomData.put(nomScientifique.getNom(),nomScientifique);

				}

			}

		} else {

			referentielNomData = new HashMap<String, ReferentielNom>(0);

		}

		return referentielNomData;

	}

	public static Map<String, String> convertirListeReferentielNomVersMap(Map<String, ReferentielNom> referentielNom) {

		Map<String, String> nomMap = new HashMap<String, String>();

		for (Iterator<String> it  = referentielNom.keySet().iterator(); it.hasNext();) {

			String cle = it.next();

			nomMap.put(cle, referentielNom.get(cle).getNom());

		}

		return nomMap;

	}

	public static Map<String, ReferentielLocalite> parserRetourReferentielLocaliteIndexeParNom(Response response) {

		final Map<String, ReferentielLocalite> referentielLocaliteData;

		final JSONValue responseValue = JSONParser.parse(response.getText());

		JSONArray reponse = null;

		// si c'est un tableau

		if ((reponse = responseValue.isArray()) != null) {

			JSONArray localites;

			final int taillemax = reponse.size();

			referentielLocaliteData = new HashMap<String, ReferentielLocalite>(taillemax);

			for (int i = 0; i < taillemax; i++) {

				if ((localites = reponse.get(i).isArray()) != null) {

					String localite = ((JSONString) localites.get(0)).stringValue();

					String codeLocalite  = ((JSONString) localites.get(1)).stringValue();

					ReferentielLocalite com = new ReferentielLocalite(localite, codeLocalite);

					referentielLocaliteData.put(com.getLocalite() + com.getCodeLocalite(), com);

				}

			}

		} else {

			referentielLocaliteData = new HashMap<String, ReferentielLocalite>(0);

		}

		return referentielLocaliteData;

	}

	public static Map<String, String> convertirListeReferentielLocaliteVersMap(Map<String, ReferentielLocalite> referentielLocalite) {

		Map<String, String> locMap = new HashMap<String, String>();

		for (Iterator<String> it  = referentielLocalite.keySet().iterator(); it.hasNext();) {

			String cle = it.next();

			locMap.put(cle, referentielLocalite.get(cle).getLocalite());

		}

		return locMap;

	}

}