/tags/v2.25-scarificateur/src/org/tela_botanica/client/util/ChampSaisieEtendu.java |
---|
New file |
0,0 → 1,122 |
package org.tela_botanica.client.util; |
import java.util.ArrayList; |
import java.util.Iterator; |
import java.util.List; |
import java.util.Map; |
import org.tela_botanica.client.cel2; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO; |
import org.tela_botanica.client.modeles.objets.Configuration; |
import org.tela_botanica.client.modeles.objets.Utilisateur; |
import org.tela_botanica.client.util.autocompletion.AutoCompletionComboBox; |
import com.google.gwt.core.client.Callback; |
import com.google.gwt.http.client.Response; |
import com.google.gwt.user.client.Timer; |
import com.gwtext.client.core.EventCallback; |
import com.gwtext.client.core.EventObject; |
import com.gwtext.client.core.Ext; |
import com.gwtext.client.core.ListenerConfig; |
import com.gwtext.client.data.ArrayReader; |
import com.gwtext.client.data.FieldDef; |
import com.gwtext.client.data.MemoryProxy; |
import com.gwtext.client.data.Record; |
import com.gwtext.client.data.RecordDef; |
import com.gwtext.client.data.Store; |
import com.gwtext.client.data.StringFieldDef; |
import com.gwtext.client.widgets.Component; |
import com.gwtext.client.widgets.ToolTip; |
import com.gwtext.client.widgets.form.ComboBox; |
import com.gwtext.client.widgets.form.Field; |
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
public class ChampSaisieEtendu extends AutoCompletionComboBox { |
private String cle = null; |
private String label = null; |
private String description = null; |
private ToolTip tpDesc = null; |
public ChampSaisieEtendu(String label, String cle, String urlRequete) { |
super(label, urlRequete); |
this.cle =cle; |
this.label = label; |
// A activer pour télécharger la description |
// si jamais on le décide |
addListener(new ComboBoxListenerAdapter() { |
@Override |
public void onRender(Component component) { |
ChampSaisieEtendu.this.getEl().addListener("mouseover", new EventCallback() { |
@Override |
public void execute(EventObject e) { |
if(description == null) { |
telechargerEtAfficherDescriptionDistante(); |
} else { |
afficherDescription(description); |
} |
} |
}); |
} |
}); |
} |
private void telechargerEtAfficherDescriptionDistante() { |
ListeReferentielChampsEtendusDAO.telechargerDescriptionWikini(cle, new Callback<String, String>() { |
@Override |
public void onSuccess(String description) { |
ChampSaisieEtendu.this.description = description; |
afficherDescription(description); |
} |
@Override |
public void onFailure(String description) { |
afficherDescription(description); |
} |
}); |
} |
private void afficherDescription(String description) { |
if(!description.trim().isEmpty()) { |
if(tpDesc == null) { |
tpDesc = new ToolTip(description); |
tpDesc.applyTo(this.getElement()); |
tpDesc.showAt(ChampSaisieEtendu.this.getEl().getX(), ChampSaisieEtendu.this.getEl().getY()); |
} else { |
tpDesc.show(); |
} |
} |
} |
public String getCle() { |
return cle; |
} |
public String getLabel() { |
return label; |
} |
@Override |
protected Map<String, String> parserResultatRequete(Response response) { |
return ListeReferentielChampsEtendusDAO.parserRetourListeValeursChampsEtendus(response); |
} |
@Override |
protected void onModificationValeur() { |
// TODO Auto-generated method stub |
} |
@Override |
protected void onSelectionValeur() { |
// TODO Auto-generated method stub |
} |
@Override |
protected void onValidationSaisie() { |
// TODO Auto-generated method stub |
} |
} |
/tags/v2.25-scarificateur/src/org/tela_botanica/client/util/Util.java |
---|
New file |
0,0 → 1,636 |
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.i18n.Msg; |
import org.tela_botanica.client.modeles.objets.ChampEtendu; |
import org.tela_botanica.client.modeles.objets.Configuration; |
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.core.client.Callback; |
import com.google.gwt.http.client.Request; |
import com.google.gwt.http.client.RequestCallback; |
import com.google.gwt.http.client.RequestException; |
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.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]*\\)", "").trim(); |
} |
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) { |
if(numMois >= 1 && numMois <= 12) { |
return Msg.get("mois-"+numMois); |
} else { |
return Msg.get("mois-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 boolean estLaCorse(String s) { |
// Les générations futures d'informaticiens me jugeront |
// (et éventuellement géreront mieux le cas de la Corse que je ne l'ai fait) |
return s.toUpperCase().equals("2A") || s.toUpperCase().equals("2B"); |
} |
public static boolean estUnDepartement(String s) { |
return estUnNombre(s) || estLaCorse(s); |
} |
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) { |
// MiaOu |
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); |
} |
} |
} 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; |
} |
public static Map<String, String> parserRetourImportObs(String json) { |
final JSONValue responseValue = JSONParser.parse(json); |
JSONObject reponse = null; |
Map<String, String> retourImport = new HashMap<String,String>(); |
// si c'est un objet |
if ((reponse = responseValue.isObject()) != null) { |
Iterator<String> it = reponse.keySet().iterator(); |
while(it.hasNext()) { |
String cle = it.next(); |
String valeur = reponse.get(cle).isString().stringValue(); |
retourImport.put(cle, valeur); |
} |
} |
return retourImport; |
} |
public static void envoyerRequeteStatsUpload(final Callback<String, String> cb) { |
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl() |
+"/ImportXLS") ; |
try { |
rb.sendRequest(null, new RequestCallback() { |
@Override |
public void onError(Request request, Throwable exception) { |
// TODO Auto-generated method stub |
} |
@Override |
public void onResponseReceived(Request request, |
Response response) { |
cb.onSuccess(response.getText()); |
} |
}) ; |
} catch (RequestException e) { |
// TODO Auto-generated catch block |
e.printStackTrace(); |
} |
} |
public static native void LogVersFirebug(Object o) /*-{ |
if (!!($wnd.console && $wnd.console.log)) { |
console.log(o); |
} |
}-*/; |
public static String buildStackTrace(Throwable t, String log) { |
if (t != null) { |
log += t.getClass().toString(); |
log += t.getMessage(); |
// |
StackTraceElement[] stackTrace = t.getStackTrace(); |
if (stackTrace != null) { |
StringBuffer trace = new StringBuffer(); |
for (int i = 0; i < stackTrace.length; i++) { |
trace.append(stackTrace[i].getClassName() + "." + stackTrace[i].getMethodName() + "(" |
+ stackTrace[i].getFileName() + ":" + stackTrace[i].getLineNumber()); |
} |
log += trace.toString(); |
} |
// |
Throwable cause = t.getCause(); |
if (cause != null && cause != t) { |
log += buildStackTrace(cause, "CausedBy:\n"); |
} |
} |
return log; |
} |
public static String obtenirCodeLangueSysteme() { |
String langueSystemeBrute = obtenirLangueSysteme(); |
// le navigateur peut éventuellement renvoyer une chaine de la forme |
// en-us ou fr-fr par exemple |
String[] lngTab = langueSystemeBrute.split("-"); |
return (lngTab.length > 0) ? lngTab[0] : null; |
} |
public static native String obtenirLangueSysteme() /*-{ |
lang = ""; |
if (!!($wnd.navigator && $wnd.navigator.language)) { |
lang = window.navigator.language; |
} |
return lang; |
}-*/; |
public static native String utf8ToB64(String str) /*-{ |
return window.btoa(unescape(encodeURIComponent( str ))); |
}-*/; |
public static native String b64ToUtf8(String str) /*-{ |
return decodeURIComponent(escape(window.atob( str ))); |
}-*/; |
} |
/tags/v2.25-scarificateur/src/org/tela_botanica/client/util/FormulaireSaisieChampEtendu.java |
---|
New file |
0,0 → 1,290 |
package org.tela_botanica.client.util; |
import java.util.ArrayList; |
import java.util.HashMap; |
import java.util.Iterator; |
import java.util.List; |
import java.util.Map; |
import org.tela_botanica.client.i18n.Msg; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO; |
import org.tela_botanica.client.modeles.objets.ListeGroupesChampsEtendus; |
import org.tela_botanica.client.modeles.objets.Utilisateur; |
import org.tela_botanica.client.util.autocompletion.AutoCompletionComboBox; |
import com.google.gwt.core.client.Callback; |
import com.google.gwt.event.dom.client.ChangeEvent; |
import com.google.gwt.event.dom.client.ChangeHandler; |
import com.google.gwt.http.client.Response; |
import com.google.gwt.http.client.URL; |
import com.google.gwt.user.client.Window; |
import com.google.gwt.user.client.ui.HTML; |
import com.google.gwt.user.client.ui.HorizontalPanel; |
import com.google.gwt.user.client.ui.Label; |
import com.google.gwt.user.client.ui.ListBox; |
import com.gwtext.client.core.EventCallback; |
import com.gwtext.client.core.EventObject; |
import com.gwtext.client.core.Ext; |
import com.gwtext.client.widgets.Button; |
import com.gwtext.client.widgets.Panel; |
import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
import com.gwtext.client.widgets.form.FormPanel; |
import com.gwtext.client.widgets.layout.FormLayout; |
@SuppressWarnings("unchecked") |
public abstract class FormulaireSaisieChampEtendu extends FormPanel implements Rafraichissable { |
final AutoCompletionComboBox nChamp; |
Button ajouterChampsEtenduEtFermer; |
Button ajouterChampsEtendu; |
Button annulerAjouterChampEtendu; |
String idChamp = null; |
Panel conteneurGroupesChampsEtendus; |
Panel conteneurlabelGroupe; |
ListBox listeGroupeChampsEtendus; |
HTML indicationSaisieGroupe; |
private static ListeGroupesChampsEtendus cacheGroupes; |
private static Map<String, String> cacheLabelsCle; |
private HTML descriptionChamp = null; |
private String groupeSelectionne = null; |
public FormulaireSaisieChampEtendu() { |
super(); |
setPaddings(3); |
setBodyBorder(false); |
indicationSaisieGroupe = new HTML(Msg.get("indication-saisie-groupe-champ-etendus")); |
indicationSaisieGroupe.addStyleName("aideCreerChampEtendu"); |
conteneurlabelGroupe = new Panel(); |
conteneurlabelGroupe.setStyleName("panneauEnLigne"); |
conteneurlabelGroupe.addStyleName("selecteurGroupeEtendus"); |
conteneurlabelGroupe.setBorder(false); |
Label labelGroupeChampsEtendus = new Label(Msg.get("ajouter-groupe-champ-etendus")+" :"); |
listeGroupeChampsEtendus = new ListBox(); |
listeGroupeChampsEtendus.setWidth("315px"); |
conteneurlabelGroupe.add(labelGroupeChampsEtendus); |
conteneurlabelGroupe.add(listeGroupeChampsEtendus); |
conteneurGroupesChampsEtendus = new Panel(); |
conteneurGroupesChampsEtendus.setBorder(false); |
conteneurGroupesChampsEtendus.setPaddings(0); |
conteneurGroupesChampsEtendus.setMargins(0); |
conteneurGroupesChampsEtendus.setLayout(new FormLayout()); |
conteneurGroupesChampsEtendus.setWidth("100%"); |
add(conteneurGroupesChampsEtendus); |
if(cacheGroupes == null) { |
ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null); |
lrceDao.obtenirGroupesChampsEtendus(this); |
} else { |
this.rafraichir(cacheGroupes, false); |
} |
HTML indicationSaisie = new HTML(Msg.get("indication-saisie-nom-champ-etendu")); |
indicationSaisie.addStyleName("aideCreerChampEtendu"); |
add(indicationSaisie); |
HorizontalPanel hp = new HorizontalPanel(); |
hp.setBorderWidth(0); |
nChamp = new AutoCompletionComboBox(Msg.get("nom-champ-etendu"), ListeReferentielChampsEtendusDAO.getUrlRequeteNomsChampsEtendus()) { |
@Override |
protected Map<String, String> parserResultatRequete( |
Response response) { |
Map<String, String> clesLabels = ListeReferentielChampsEtendusDAO.parserRetourListeNomsChampsEtendus(response); |
cacheLabelsCle = new HashMap<String, String>(); |
for(Map.Entry<String, String> entry : clesLabels.entrySet()){ |
cacheLabelsCle.put(entry.getValue(), entry.getKey()); |
} |
return clesLabels; |
} |
@Override |
protected void onSelectionValeur() { |
telechargerEtAfficherDescriptionChamps(cacheLabelsCle.get(nChamp.getRawValue())); |
} |
@Override |
protected void onValidationSaisie() { |
// rien à faire ici |
} |
@Override |
protected void onModificationValeur() { |
// rien à faire ici non plus |
} |
@Override |
protected String preTraiterUrlRequete(String urlRequete, String valeur) { |
return urlRequete.replace("{utilisateur}", Utilisateur.getInstance().getIdentifiantUtilisateurConsulte())+URL.encodeQueryString(valeur); |
} |
}; |
nChamp.addStyleName("panneauEnLigne"); |
add(nChamp); |
descriptionChamp = new HTML(); |
descriptionChamp.addStyleName("aideWikiChampEtendu"); |
add(descriptionChamp); |
ajouterChampsEtenduEtFermer = new Button(Msg.get("ajouter-fermer")); |
ajouterChampsEtenduEtFermer.setTooltip(Msg.get("indication-ajouter-fermer")); |
ajouterChampsEtendu = new Button(Msg.get("ajouter")); |
ajouterChampsEtendu.setTooltip(Msg.get("indication-ajouter-champ-etendu")); |
annulerAjouterChampEtendu = new Button(Msg.get("fermer")); |
annulerAjouterChampEtendu.setTooltip(Msg.get("indication-fermer-champ-etendu")); |
hp.add(ajouterChampsEtenduEtFermer); |
hp.add(ajouterChampsEtendu); |
hp.add(annulerAjouterChampEtendu); |
add(hp); |
ajouterListeners(); |
} |
private void ajouterListeners() { |
listeGroupeChampsEtendus.addChangeHandler(new ChangeHandler() { |
@Override |
public void onChange(ChangeEvent event) { |
groupeSelectionne = listeGroupeChampsEtendus.getValue(listeGroupeChampsEtendus.getSelectedIndex()); |
} |
}); |
ajouterChampsEtenduEtFermer.addListener(new ButtonListenerAdapter() { |
@Override |
public void onClick(Button button, EventObject e) { |
if(doitAjouterGroupe()) { |
surValidationMultiple(renvoyerListeChampsEtendus(groupeSelectionne)); |
} else { |
if(champEtenduEstValide()) { |
surValidation(validerEtRenvoyerChampEtendu()); |
} else { |
Window.alert(Msg.get("erreur-nom-vide-champ-etendu")); |
} |
} |
} |
}); |
ajouterChampsEtendu.addListener(new ButtonListenerAdapter() { |
@Override |
public void onClick(Button button, EventObject e) { |
if(champEtenduEstValide()) { |
surAjout(validerEtRenvoyerChampEtendu()); |
raz(); |
} else { |
Window.alert(Msg.get("erreur-nom-vide-champ-etendu")); |
} |
} |
}); |
annulerAjouterChampEtendu.addListener(new ButtonListenerAdapter() { |
@Override |
public void onClick(Button button, EventObject e) { |
surAnnulation(); |
} |
}); |
} |
public void redimensionner(int largeur) { |
nChamp.redimensionner(largeur); |
} |
private void raz() { |
idChamp = null; |
nChamp.reset(); |
nChamp.focus(); |
} |
private ChampSaisieEtendu validerEtRenvoyerChampEtendu() { |
String labelChamp = nChamp.getRawValue(); |
String cleChamp = cacheLabelsCle.containsKey(labelChamp) ? cacheLabelsCle.get(labelChamp) : labelChamp; |
ChampSaisieEtendu retour = new ChampSaisieEtendu(labelChamp, cleChamp, ListeReferentielChampsEtendusDAO.getUrlRequeteValeursChampEtendu(cleChamp)); |
retour.setId(cleChamp); |
return retour; |
} |
private List<ChampSaisieEtendu> renvoyerListeChampsEtendus(String groupe) { |
List<ChampSaisieEtendu> champsDuGroupe = new ArrayList<ChampSaisieEtendu>(); |
HashMap<String, String> listeChampsEtendus = cacheGroupes.get(groupe); |
for (Iterator<String> iterator = listeChampsEtendus.keySet().iterator(); iterator.hasNext();) { |
String cle = iterator.next(); |
String label = listeChampsEtendus.get(cle); |
ChampSaisieEtendu champ = new ChampSaisieEtendu(label, cle, ListeReferentielChampsEtendusDAO.getUrlRequeteValeursChampEtendu(cle)); |
champsDuGroupe.add(champ); |
} |
return champsDuGroupe; |
} |
private boolean doitAjouterGroupe() { |
return groupeSelectionne != null && !groupeSelectionne.equals(""); |
} |
private boolean champEtenduEstValide() { |
String valeurChamp = nChamp.getRawValue(); |
return (valeurChamp != null && !valeurChamp.isEmpty()); |
} |
public abstract void surAjout(ChampSaisieEtendu champ); |
public abstract void surAjoutMultiple(List<ChampSaisieEtendu> champs); |
public abstract void surValidation(ChampSaisieEtendu champ); |
public abstract void surValidationMultiple(List<ChampSaisieEtendu> champs); |
public abstract void surAnnulation(); |
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
if(nouvelleDonnees instanceof ListeGroupesChampsEtendus) { |
cacheGroupes = (ListeGroupesChampsEtendus)nouvelleDonnees; |
listeGroupeChampsEtendus.addItem("..."); |
for (Iterator<String> iterator = cacheGroupes.keySet().iterator(); iterator.hasNext();) { |
listeGroupeChampsEtendus.addItem(iterator.next()); |
} |
if(cacheGroupes.size() > 0) { |
conteneurGroupesChampsEtendus.add(indicationSaisieGroupe); |
conteneurGroupesChampsEtendus.add(conteneurlabelGroupe); |
doLayout(); |
} |
} |
} |
private void telechargerEtAfficherDescriptionChamps(final String cle) { |
ListeReferentielChampsEtendusDAO.telechargerDescriptionWikini(cle, new Callback<String, String>() { |
@Override |
public void onSuccess(String description) { |
afficherDescriptionEtLienWikiChampEtendu(cle, description); |
} |
@Override |
public void onFailure(String reason) { |
// rien |
} |
}); |
} |
private void afficherDescriptionEtLienWikiChampEtendu(final String cle, String description) { |
if(description.trim().isEmpty()) { |
String urlDesc = ListeReferentielChampsEtendusDAO.obtenirUrlEditionDescriptionWiki(cle); |
descriptionChamp.setHTML("<span> "+Msg.get("indication-aucune-description-champ-etendu")+".<br />" + |
Msg.get("indication-aucune-description-champ-etendu-remplir")+" :" + |
"<a id=\"lien_description_wiki_ce_"+cle+"\" href="+urlDesc+" target=\"_blank\">"+cle+"</span></span>"); |
Ext.get("lien_description_wiki_ce_"+cle).addListener("click", new EventCallback() { |
@Override |
public void execute(EventObject e) { |
ListeReferentielChampsEtendusDAO.creerPageWikini(cle); |
} |
}); |
} else { |
descriptionChamp.setHTML("<span class=\"descriptionChampEtenduTitre\">"+Msg.get("description")+" :</span> "+description); |
} |
} |
} |
/tags/v2.25-scarificateur/src/org/tela_botanica/client/util/autocompletion/AutoCompletionComboBox.java |
---|
New file |
0,0 → 1,334 |
package org.tela_botanica.client.util.autocompletion; |
import java.util.ArrayList; |
import java.util.Iterator; |
import java.util.List; |
import java.util.Map; |
import org.tela_botanica.client.cel2; |
import org.tela_botanica.client.modeles.objets.Utilisateur; |
import com.google.gwt.core.client.Callback; |
import com.google.gwt.core.client.JavaScriptObject; |
import com.google.gwt.event.dom.client.KeyCodes; |
import com.google.gwt.event.dom.client.KeyDownEvent; |
import com.google.gwt.event.dom.client.KeyDownHandler; |
import com.google.gwt.event.dom.client.KeyPressEvent; |
import com.google.gwt.event.dom.client.KeyPressHandler; |
import com.google.gwt.event.logical.shared.SelectionEvent; |
import com.google.gwt.event.logical.shared.SelectionHandler; |
import com.google.gwt.event.logical.shared.ValueChangeEvent; |
import com.google.gwt.event.logical.shared.ValueChangeHandler; |
import com.google.gwt.http.client.Request; |
import com.google.gwt.http.client.RequestBuilder; |
import com.google.gwt.http.client.RequestCallback; |
import com.google.gwt.http.client.RequestException; |
import com.google.gwt.http.client.Response; |
import com.google.gwt.http.client.URL; |
import com.google.gwt.user.client.Event; |
import com.google.gwt.user.client.Timer; |
import com.google.gwt.user.client.Window; |
import com.google.gwt.user.client.ui.ChangeListener; |
import com.google.gwt.user.client.ui.Label; |
import com.google.gwt.user.client.ui.MultiWordSuggestOracle; |
import com.google.gwt.user.client.ui.SuggestBox; |
import com.google.gwt.user.client.ui.SuggestBox.DefaultSuggestionDisplay; |
import com.google.gwt.user.client.ui.TextBox; |
import com.google.gwt.user.client.ui.SuggestBox.SuggestionDisplay; |
import com.google.gwt.user.client.ui.SuggestOracle; |
import com.google.gwt.user.client.ui.Widget; |
import com.google.gwt.user.client.ui.SuggestOracle.Suggestion; |
import com.gwtext.client.widgets.BoxComponent; |
import com.gwtext.client.widgets.Component; |
import com.gwtext.client.widgets.Container; |
import com.gwtext.client.widgets.Panel; |
import com.gwtext.client.widgets.event.PanelListener; |
import com.gwtext.client.widgets.event.PanelListenerAdapter; |
import com.gwtext.client.widgets.layout.FitLayout; |
@SuppressWarnings("unchecked") |
public abstract class AutoCompletionComboBox extends Panel { |
Label label = null; |
MultiWordSuggestOracle msu = null; |
SuggestBox suggestions = null; |
DefaultSuggestionDisplay sgd = null; |
Callback<String, String> surCopierColler = null; |
SuggestOracle.Request requeteOracle; |
SuggestOracle.Callback callBackOracle; |
Timer suggestionTimer = null; |
int tempsAvantRequete = 500; |
Map<String, String> possibilites = null; |
String urlRequete = ""; |
public AutoCompletionComboBox(String nomLabel, String urlRequete) { |
this.setStyleName("champAutoComplete"); |
this.label = new Label(nomLabel+":"); |
this.urlRequete = urlRequete; |
sgd = new SuggestBox.DefaultSuggestionDisplay(); |
msu = new MultiWordSuggestOracle() { |
@Override |
public void requestSuggestions(Request request, Callback callback) { |
List<MultiWordSuggestion> retenus = new ArrayList<MultiWordSuggestion>(); |
Iterator<String> it = possibilites.keySet().iterator(); |
while (it.hasNext()) { |
String cle = it.next(); |
String cleAffichee = preTraiterValeurAvantAffichage(possibilites.get(cle)); |
MultiWordSuggestion muWoSug = new MultiWordSuggestion(possibilites.get(cle), cleAffichee); |
retenus.add(muWoSug); |
} |
Response reponse = new Response(retenus); |
callback.onSuggestionsReady(request, reponse); |
} |
}; |
suggestions = new SuggestBox(msu, new TextBox(), sgd) { |
public void onBrowserEvent(Event event) { |
switch (event.getTypeInt()) { |
case Event.ONPASTE: { |
if(surCopierColler != null) { |
surCopierColler.onSuccess(suggestions.getValueBox().getValue()); |
} |
} |
break; |
default: |
// WTF: Curieux bloc qui est nécessaire car si on appelle pas super.onBrowserEvent |
// aucun évènement ne fonctionne et si on le fait, cela génère des nullPointerException |
// donc on transige en l'appelant dans un try catch |
try { |
super.onBrowserEvent(event); |
} catch (Exception e) { |
// à priori rien à faire |
} |
} |
} |
}; |
suggestions.setAutoSelectEnabled(false); |
setLayout(new FitLayout()); |
add(label); |
add(suggestions); |
gererEvenements(); |
} |
public void gererEvenements() { |
suggestions.addKeyDownHandler(new KeyDownHandler() { |
@Override |
public void onKeyDown(KeyDownEvent event) { |
// Lorsque la liste de suggestions est ouverte, une frappe sur entrée selectionne la valeur |
// Si elle est fermée, elle déclenche la fonction abstraite de validation (utile pour les champs |
// du genre station, milieu etc... et la saisie d'obs rapide |
if(event.getNativeKeyCode() == KeyCodes.KEY_ENTER) { |
if((sgd == null || !sgd.isSuggestionListShowing())) { |
onValidationSaisie(); |
event.stopPropagation(); |
return; |
} else { |
// Dans les autres cas, un appui sur entrée ne doit pas redéclencher l'autcomplétion |
return; |
} |
} |
if(event.getNativeKeyCode() == KeyCodes.KEY_DOWN) { |
// Un appui sur flèche bas permet de demander toute la liste |
if(!sgd.isSuggestionListShowing()) { |
requeteToutesSuggestions(); |
} |
} |
// Tout autre frappe d'un caractère "normal" déclenche le timer d'autocomplétion |
if(!KeyDownEvent.isArrow(event.getNativeKeyCode())) { |
gererTimer(); |
} |
} |
}); |
requeteOracle = new SuggestOracle.Request(); |
callBackOracle = new SuggestOracle.Callback() { |
public void onSuggestionsReady(SuggestOracle.Request request, SuggestOracle.Response response) { |
suggestions.showSuggestionList(); |
} |
}; |
suggestions.addSelectionHandler(new SelectionHandler<SuggestOracle.Suggestion>(){ |
@Override |
public void onSelection(SelectionEvent<Suggestion> event) { |
onSelectionValeur(); |
} |
}); |
suggestions.addValueChangeHandler(new ValueChangeHandler<String>() { |
@Override |
public void onValueChange(ValueChangeEvent<String> event) { |
onModificationValeur(); |
} |
}); |
surCopierColler = new Callback<String, String>() { |
@Override |
public void onSuccess(String result) { |
gererTimer(); |
} |
@Override |
public void onFailure(String reason) { |
// rien à faire ça n'échoue jamais |
} |
}; |
addListener(new PanelListenerAdapter() { |
@Override |
public void onResize(BoxComponent component, int adjWidth, int adjHeight, |
int rawWidth, int rawHeight) { |
redimensionner(rawWidth); |
} |
}); |
} |
public void redimensionner(final int largeur) { |
suggestions.setWidth((largeur - label.getOffsetWidth() - 13)+"px"); |
} |
public void gererTimer() { |
if(suggestionTimer == null) { |
suggestionTimer = new Timer() { |
public void run() { |
requeteSuggestions(); |
} |
}; |
suggestionTimer.schedule(tempsAvantRequete); |
} else { |
suggestionTimer.schedule(tempsAvantRequete); |
} |
} |
public void setTempsAvantRequete(int temps) { |
tempsAvantRequete = temps; |
} |
public int getTempsAvantRequete(int temps) { |
return tempsAvantRequete; |
} |
public void requeteToutesSuggestions() { |
// Cette méthode permet de demander l'autocomplétion même si |
// la valeur saisie est vide (cas de l'appui sur flèche bas) |
envoyerRequeteSuggestions("*"); |
} |
public void requeteSuggestions() { |
// Suppression des espaces et caractères inutiles |
String valeur = suggestions.getValue().trim().isEmpty() ? null : suggestions.getValue().trim(); |
// ceci permet au composant qui utilise l'autocomplétion |
// d'annuler une requete et également d'éviter de faire une requête lors du vidage du champ |
if(valeur == null) { |
return; |
} |
envoyerRequeteSuggestions(valeur); |
} |
private void envoyerRequeteSuggestions(final String valeur) { |
final String urlRequeteFmt = preTraiterUrlRequete(urlRequete, valeur); |
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, urlRequeteFmt) ; |
try { |
rb.sendRequest(null, new RequestCallback() { |
public void onError(final Request request, final Throwable exception) { |
// TODO Auto-generated method stub |
} |
public void onResponseReceived(final Request request, |
final Response response) { |
surReponseRequete(valeur, response); |
} |
}) ; |
} catch (RequestException e) { |
// TODO Auto-generated catch block |
e.printStackTrace(); |
} |
} |
public void surReponseRequete(String requete, Response response) { |
possibilites = parserResultatRequete(response); |
msu.clear(); |
Iterator<String> it = possibilites.keySet().iterator(); |
while (it.hasNext()) { |
msu.add(possibilites.get(it.next())); |
} |
requeteOracle.setQuery(requete); |
if(requete.equals("*")) { |
// TODO : il y a peut être une méthode plus simple |
// mais ceci permet d'afficher les suggestions en cas d'appui |
// sur bas lorsque la liste est vide |
msu.setDefaultSuggestionsFromText(possibilites.values()); |
SuggestOracle.Request rq = new SuggestOracle.Request(); |
rq.setQuery(null); |
msu.requestDefaultSuggestions(rq, callBackOracle); |
} else { |
msu.requestSuggestions(requeteOracle, callBackOracle); |
} |
} |
public String getText() { |
return suggestions.getText(); |
} |
public String getRawValue() { |
return suggestions.getText(); |
} |
public void setValue(String texte) { |
suggestions.setText(texte); |
} |
public void reset() { |
suggestions.setValue(""); |
} |
public void setTabIndex(int index) { |
suggestions.setTabIndex(index); |
} |
public String getLabelText() { |
return label.getText(); |
} |
public int getFieldWidth() { |
return suggestions.getOffsetWidth(); |
} |
public int getLabelWidth() { |
return label.getOffsetWidth(); |
} |
public void agrandirChamp(int largeur) { |
suggestions.setWidth(largeur+"px"); |
} |
protected String preTraiterValeurAvantAffichage(String valeur) { |
return valeur; |
} |
protected String preTraiterUrlRequete(String urlRequete, String valeur) { |
return urlRequete+URL.encodeQueryString(valeur); |
} |
protected abstract Map<String, String> parserResultatRequete(Response response); |
protected abstract void onModificationValeur(); |
protected abstract void onSelectionValeur(); |
protected abstract void onValidationSaisie(); |
} |
/tags/v2.25-scarificateur/src/org/tela_botanica/client/util/MotsClesUtilitaire.java |
---|
New file |
0,0 → 1,207 |
package org.tela_botanica.client.util; |
import java.util.HashMap; |
import org.tela_botanica.client.cel2; |
import com.google.gwt.json.client.JSONArray; |
import com.google.gwt.json.client.JSONObject; |
import com.google.gwt.user.client.Window; |
import com.gwtext.client.data.Node; |
import com.gwtext.client.data.Tree; |
import com.gwtext.client.widgets.tree.TreeNode; |
public class MotsClesUtilitaire { |
//TODO rassembler tout ce qui construit les arbres de mots clés ici |
private static String[] caracteresInterdits = {"\\", "/", ","}; |
public static String obtenirCheminParent(String cheminMotCle) { |
String[] tabChemin = cheminMotCle.split("/"); |
String cheminParent = "/"; |
if(tabChemin.length >= 1) { |
for(int i = 1; i < tabChemin.length - 1; i++) { |
cheminParent += tabChemin[i]+"/"; |
} |
} |
return cheminParent; |
} |
public static Object[] construireArbre(String NomRacine, String idRacine, |
JSONArray arbreJson, boolean afficherCheckbox) { |
Tree arbreMotsCles = new Tree() ; |
HashMap<String, String> motsCles = new HashMap<String, String>(0); |
HashMap<String, String> parentes = new HashMap<String, String>(); |
final int taillemax = arbreJson.size(); |
// on crée un arbre vide |
TreeNode root = new TreeNode(); |
root.setId(idRacine); |
root.setText(NomRacine); |
String[] usObjRacine = {NomRacine, idRacine}; |
root.setUserObject(usObjRacine); |
arbreMotsCles.setRootNode(root); |
// le mot clé racine possède le chemin racine ("/") |
parentes.put("/", idRacine); |
// pour chacun des élements du tableau |
for (int j = 0; j < taillemax; j++) { |
// on extrait les élements du tableau |
if (arbreJson.get(j).isObject() != null) { |
JSONObject noeud = (JSONObject) arbreJson.get(j); |
String idMotCle = noeud.get("id_mot_cle") |
.isString().stringValue(); |
String motCle = noeud.get("mot_cle").isString() |
.stringValue(); |
// le chemin est mis en minuscule afin de fusionner toutes |
// la variantes minuscules majuscule d'un mot clé |
// qui peuvent poser problème |
String chemin = noeud.get("chemin").isString() |
.stringValue().toLowerCase(); |
String cheminParent = MotsClesUtilitaire.obtenirCheminParent(chemin); |
String parent = parentes.get(cheminParent); |
String[] usObj = {motCle, idMotCle}; |
// et on construit l'arbre en ajoutant les noeuds un à un (qui sont renvoyés |
// dans l'ordre hierarchique de leur niveau |
// ce qui permet de les traiter séquentiellement) |
TreeNode node = new TreeNode(); |
node.setId(idMotCle); |
node.setText(motCle); |
if(afficherCheckbox) { |
node.setChecked(false); |
} |
Node parentNode = arbreMotsCles.getNodeById(parent); |
node.setUserObject(usObj); |
parentNode.appendChild(node); |
parentes.put(chemin, idMotCle); |
motsCles.put(idMotCle, motCle); |
} |
} |
Object[] retour = {arbreMotsCles, motsCles}; |
return retour; |
} |
/** |
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un |
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième |
* |
* @param ndPereOriginal |
* le père des noeuds de l'arbre original |
* @param ndPereCopie |
* le père qui va recevoir les copies |
*/ |
public static void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie, boolean afficherCheckbox) { |
if (ndPereCopie != null && ndPereOriginal != null) { |
Node[] ndNodeFils = ndPereOriginal.getChildNodes(); |
for (int i = 0; i < ndNodeFils.length; i++) { |
String[] usObj = (String[]) ndNodeFils[i].getUserObject(); |
TreeNode child = new TreeNode(usObj[0]); |
child.setId(usObj[1]); |
if(afficherCheckbox) { |
child.setChecked(false); |
} |
child.setUserObject(usObj); |
ndPereCopie.appendChild(child); |
if (!ndNodeFils[i].isLeaf()) { |
copierFilsNoeud(ndNodeFils[i], child, afficherCheckbox); |
} |
} |
} |
} |
public static TreeNode ajouterNoeud(TreeNode parent, boolean afficherCheckbox) { |
// on crée un nouveau noeud vide |
TreeNode nd = new TreeNode(""); |
nd.setCls("x-view-treenode-keyword"); |
if(afficherCheckbox) { |
nd.setChecked(true); |
} |
// on associe un objet au noeud qui contient des infos |
String[] usObject = new String[2]; |
// l'objet contient le nom du noeud |
usObject[0] = ""; |
usObject[1] = ""; |
nd.setUserObject(usObject); |
String cheminTemporaireAjout = parent.getPath()+"/"+nd.getId(); |
nd.setId(cheminTemporaireAjout); |
return nd; |
} |
public static String getChaineCaracteresInterdits() { |
String interdits = ""; |
for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) { |
interdits += MotsClesUtilitaire.caracteresInterdits[i]+" "; |
} |
return interdits; |
} |
public static boolean estUnMotCleAutorise(String motCle) { |
boolean valide = !motCle.trim().isEmpty(); |
for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) { |
if(motCle.indexOf(MotsClesUtilitaire.caracteresInterdits[i]) != -1) { |
valide = false; |
break; |
} |
} |
return valide; |
} |
public static boolean estUnePositionAutorisee(TreeNode node, Node parent, String text) { |
if(parent == null) { |
parent = node.getParentNode(); |
} |
text = normaliserChaine(text); |
Node[] noeudsFreres = parent.getChildNodes(); |
boolean ok = true; |
for(int i = 0; i <= noeudsFreres.length; i++) { |
if(noeudsFreres[i] != null) { |
String cheminFrere = normaliserChaine(noeudsFreres[i].getPath()); |
String cheminNoeud = normaliserChaine(node.getPath()); |
String texteNoeudfrere = normaliserChaine(((String[])noeudsFreres[i].getUserObject())[0]); |
if(!cheminFrere.equals(cheminNoeud) && text.equals(texteNoeudfrere)) { |
ok = false; |
} |
} |
} |
return ok; |
} |
public static String normaliserChaine(String chaine) { |
return supprimerAccents(chaine).toLowerCase().trim(); |
} |
public static String supprimerAccents(String chaine) { |
String s = chaine; |
s = s.replaceAll("[èéêë]","e"); |
s = s.replaceAll("[ûùü]","u"); |
s = s.replaceAll("[ïî]","i"); |
s = s.replaceAll("[àâ]","a"); |
s = s.replaceAll("ô","o"); |
s = s.replaceAll("[ÈÉÊË]","E"); |
s = s.replaceAll("[ÛÙÜ]","U"); |
s = s.replaceAll("[ÏÎ]","I"); |
s = s.replaceAll("[ÀÂ]","A"); |
s = s.replaceAll("Ô","O"); |
return s; |
} |
} |
/tags/v2.25-scarificateur/src/org/tela_botanica/client/util/Analytics.java |
---|
New file |
0,0 → 1,68 |
package org.tela_botanica.client.util; |
import org.tela_botanica.client.modeles.objets.Configuration; |
import org.tela_botanica.client.util.Util; |
public class Analytics { |
/** |
* Envoie une notification à Google Analytics, comme quoi la page "url" a été visitée; |
* passer par pageVisitee() pour s'assurer qu'on est bien en prod |
* |
* @param url adresse ou surnom de la page visitée |
*/ |
public static native void pageVisiteeNatif(String url) /*-{ |
if (url == "") { |
url = $wnd.location.href; |
} |
$wnd.ga('send', 'pageview', url); |
}-*/; |
/** |
* Proxy pour evenementNatif() qui n'envoie l'événement que si on est en prod |
*/ |
public static void pageVisitee(String url) { |
if (Configuration.isProd()) { |
//Util.LogVersFirebug("Page vue: " + url); |
Analytics.pageVisiteeNatif(url); |
} else { |
} |
} |
public static void pageVisitee() { |
pageVisitee(""); |
} |
/** |
* Envoie une notification à Google Analytics, comme quoi l'événement "action" a été déclenché |
* sur la ressource "categorie" - passer par evenement() pour s'assurer qu'on |
* est bien en prod |
* |
* @param categorie - la ressource sur laquelle l'utilisateur a agi |
* @param action - ce que l'utilisateur a fait avec cette ressource |
* @param label - un bout de JSON avec des détails |
* @param nombre - nombre d'actions à enregistrer |
*/ |
public static native void evenementNatif(String categorie, String action, String label, int nombre) /*-{ |
$wnd.ga('send', 'event', categorie, action, label, nombre); |
}-*/; |
/** |
* Proxy pour evenementNatif() qui n'envoie l'événement que si on est en prod |
*/ |
public static void evenement(String categorie, String action, String label, int nombre) { |
if (Configuration.isProd()) { |
//Util.LogVersFirebug("Evenement: " + categorie + ", " + action + ", " + label + ", " + nombre); |
Analytics.evenementNatif(categorie, action, label, nombre); |
} |
} |
public static void evenement(String categorie, String action, String label) { |
Analytics.evenement(categorie, action, label, 1); |
} |
public static void evenement(String categorie, String action) { |
Analytics.evenement(categorie, action, "", 1); |
} |
} |
/tags/v2.25-scarificateur/src/org/tela_botanica/client/util/RequestBuilderWithCredentials.java |
---|
New file |
0,0 → 1,28 |
package org.tela_botanica.client.util; |
import org.tela_botanica.client.modeles.objets.Utilisateur; |
import com.google.gwt.http.client.RequestBuilder; |
public class RequestBuilderWithCredentials extends RequestBuilder { |
/** |
* Crée une requête avec des headers "Credentials" pour CORS et "Authorization" contenant |
* le jeton (s'il existe) |
*/ |
public RequestBuilderWithCredentials(Method httpMethod, String url) { |
this(httpMethod, url, true); |
} |
/** |
* Crée une requête avec des headers "Credentials" pour CORS, et si authorizationHeader vaut true, |
* un header "Authorization" contenant le jeton (s'il existe) |
*/ |
public RequestBuilderWithCredentials(Method httpMethod, String url, boolean authorizationHeader) { |
super(httpMethod, url); |
if(authorizationHeader && (Utilisateur.getJeton() != null && !Utilisateur.getJeton().isEmpty())) { |
this.setHeader("Authorization", Utilisateur.getJeton()); |
} |
this.setIncludeCredentials(true); |
} |
} |