Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 2910 → Rev 2911

/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);
}
}