Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
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 com.google.gwt.dom.client.Element;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONString;
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 commune = obs.getLocalite(); 
                String lieuDit = obs.getLieudit();
                String station = obs.getStation();
                
                String lieuCommuneFormate = "";
                String lieuDitFormate = "";
                String stationFormatee = "";
                
                if(commune != null && !commune.contains("000null") && !commune.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);
                                }
                                lieuCommuneFormate += idLoc+" - ";
                        }
                        lieuCommuneFormate += commune;
                        lieuModele = lieuModele.replaceAll("IDLOCCOMMUNE", lieuCommuneFormate);
                } else {
                        
                        lieuModele = lieuModele.replaceAll("IDLOCCOMMUNE,", lieuCommuneFormate);
                }
                
                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 obtenirDepartementAPartirChaineCommune(String departement, String commune) {
                
                String dep = "";
                
                if(departement == null) {
                        departement = "";
                }
                
                if(departement.equals("000null") || departement.equals("")) {
                                        
                        String[] depCom = commune.split(" ");
                        if(depCom.length > 1) {
                                dep = depCom[1].replace('(', ' ');
                        } else {
                                dep = "";
                        }
                } else {
                        dep = departement;
                }
                
                dep = dep.replace(')', ' ');
                dep = dep.trim();
                dep = dep.replace('\\',' ');
                dep = dep.trim();
                
                try
                {
                        int nDep = Integer.parseInt(dep);
                        if(nDep > 0 && nDep < 110) {
                                departement = dep ;
                        }
                        
                        if(departement.length() == 4) {
                                departement = "0"+departement;
                        }
                        
                        departement = departement.substring(0,2);
                }
                catch(NumberFormatException e)
                {
                        departement = "" ;
                }
                
                return departement;
        }
        
        public static String supprimerNumDepartementChaineLocalite(String chaineLocaliteComplete) {
                return chaineLocaliteComplete.replaceAll(" \\([0-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 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");
        }

}