| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ReferentielNom.java |
|---|
| New file |
| 0,0 → 1,54 |
| package org.tela_botanica.client.modeles; |
| /** |
| * |
| * Classe representant un element du referentiel de nom |
| * |
| */ |
| public class ReferentielNom { |
| private String nom=null; |
| private String numeroNom=null; |
| public ReferentielNom() { |
| } |
| /** |
| * @param nom |
| * @param numeroNom |
| * |
| */ |
| public ReferentielNom(String nom, String numeroNom) { |
| this.nom = nom; |
| this.numeroNom = numeroNom; |
| } |
| public String getNom() { |
| return nom; |
| } |
| public String getNumeroNom() { |
| return numeroNom; |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeReferentielNom.java |
|---|
| New file |
| 0,0 → 1,52 |
| package org.tela_botanica.client.modeles; |
| import java.util.HashMap; |
| /** |
| * table de hachage composée de noms, renvoyé par les objets de type DAO |
| * pour les noms |
| * La clé est l'identifiant du nom dans la base de données, et la valeur un objet |
| * de type ReferentielNom |
| * @author david delon |
| * |
| */ |
| public class ListeReferentielNom extends HashMap<String, ReferentielNom> { |
| private static final long serialVersionUID = 3214510270773281540L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeReferentielNom() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeReferentielNom(int taille) |
| { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param ic un tableau d'ImageCarnet |
| */ |
| public ListeReferentielNom(ReferentielNom[] nom) |
| { |
| super() ; |
| for (int i = 0; i < nom.length; i++) |
| { |
| if(nom[i] != null && nom[i] instanceof ReferentielNom) |
| { |
| this.put(nom[i].getNumeroNom(),nom[i]); |
| } |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ImageCarnet.java |
|---|
| New file |
| 0,0 → 1,381 |
| package org.tela_botanica.client.modeles; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Set; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * |
| * Classe representant une image du carnet, elle ne contient pas d'image à |
| * proprement parler mais plutôt les informations associées ainsi que l'url |
| * distante. C'est une table de hachage qui contient des paires propriété/valeur |
| * |
| */ |
| public class ImageCarnet extends HashMap<String, String> { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = -6220175386957259859L; |
| /** |
| * Constructeur avec un objet JSON |
| * |
| * @param image |
| */ |
| public ImageCarnet(JSONObject image) { |
| // l'objet JSON est une table de hachage |
| Set<String> im = image.keySet(); |
| // on la parcourt pour chaque clé |
| for (Iterator<String> iterator = im.iterator(); iterator.hasNext();) { |
| // si elle est associée à une valeur, on l'ajoute |
| String key = iterator.next(); |
| if (image.get(key).isString() != null) { |
| String valeur = image.get(key).isString().stringValue(); |
| this.put(key, valeur); |
| } else { |
| // sinon on ajoute la clé avec une valeur vide |
| String valeur = " "; |
| this.put(key, valeur); |
| } |
| } |
| } |
| /** |
| * Surcharge de toString qui affiche toutes les propriétés de l'image |
| */ |
| public String toString() { |
| String valeur = " "; |
| for (Iterator<String> iterator = this.keySet().iterator(); iterator |
| .hasNext();) { |
| String key = iterator.next(); |
| if (this.get(key) != null) { |
| valeur += "cle : " + key + " valeur :" + this.get(key) + "\n"; |
| } |
| } |
| return valeur; |
| } |
| /** |
| * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par |
| * cette fonction qui retire les charactères nuls qui font planter |
| * l'affichage, il ne faut pas utiliser get directement |
| * |
| * @param cle |
| * @return la valeur associée à la clé |
| */ |
| public String renvoyerValeurCorrecte(String cle) { |
| if (this.containsKey((cle))) { |
| String valeur = this.get(cle); |
| if (valeur.equals("null") || valeur == null) { |
| return " "; |
| } else { |
| char nullChar = '\u0000'; |
| String sNull = "" + nullChar; |
| valeur = valeur.replaceAll(sNull, ""); |
| return valeur; |
| } |
| } else { |
| return " "; |
| } |
| } |
| /** |
| * Acesseur pour l'id de l'image |
| * |
| * @return l'id de l'image |
| */ |
| public String getId() { |
| return renvoyerValeurCorrecte("ci_id_image"); |
| } |
| /** |
| * Acesseur pour le numero d'ordre de l'image |
| * |
| * @return l'ordre de l'image |
| */ |
| public String getOrdre() { |
| return renvoyerValeurCorrecte("ci_ordre"); |
| } |
| /** |
| * Base de l'url serveur pour les images |
| * |
| * @return url racine pour les images |
| */ |
| public String getBaseUrl() { |
| return Configuration.getImageBaseUrl() ; |
| } |
| /** |
| * Renvoie le nom de base du fichier image et ses sous dossier |
| * |
| * @return le nom de base du fichier de type (XXX_XXX_XXX), et ses sous |
| * dossier |
| */ |
| public String[] getBaseFileName() { |
| String id = getId(); |
| int maxZeros = 9 - id.length(); |
| for (int i = 0; i < maxZeros; i++) { |
| id = "0" + id; |
| } |
| String dossierNv1 = id.substring(0, 3); |
| String dossierNv2 = id.substring(3, 6); |
| String fichierNv = id.substring(6, 9); |
| String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv; |
| String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 }; |
| return infosFichier; |
| } |
| /** |
| * Renvoie le chemin et nom du fichier grand format |
| * |
| * @return le chemin du fichier grand format |
| */ |
| public String getLUrl() { |
| String[] infosFichier = getBaseFileName(); |
| return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/L/" |
| + infosFichier[0] + "_L.jpg"; |
| } |
| /** |
| * Renvoie le chemin et nom du fichier petit format |
| * |
| * @return le chemin du fichier petit format |
| */ |
| public String getSUrl() { |
| String[] infosFichier = getBaseFileName(); |
| return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/S/" |
| + infosFichier[0] + "_S.jpg"; |
| } |
| /** |
| * Renvoie le chemin et nom du fichier moyen format |
| * |
| * @return le chemin du fichier moyen format |
| */ |
| public String getMUrl() { |
| String[] infosFichier = getBaseFileName(); |
| return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/M/" |
| + infosFichier[0] + "_M.jpg"; |
| } |
| /** |
| * Renvoie la taille de l'image |
| * |
| * @return un tableau de deux string contenant la hauteur puis la largeur |
| */ |
| public String[] getTailleImage() { |
| String[] XY = { renvoyerValeurCorrecte("ci_meta_height"), |
| renvoyerValeurCorrecte("ci_meta_width") }; |
| return XY; |
| } |
| public String[] getNote() { |
| String[] note = { renvoyerValeurCorrecte("ci_note_image") }; |
| return note; |
| } |
| /** |
| * Renvoie la date exif associée à l'image |
| * |
| * @return la date associée à l'image |
| */ |
| public String getDate() { |
| if(renvoyerValeurCorrecte("ci_meta_date").equals("00/00/0000")) |
| { |
| return "" ; |
| } |
| return renvoyerValeurCorrecte("ci_meta_date"); |
| } |
| /** |
| * Renvoie la ville associée à l'image |
| * |
| * @return la ville iptc |
| */ |
| public Object getIptcCity() { |
| return renvoyerValeurCorrecte("ci_meta_iptc_city"); |
| } |
| /** |
| * Renvoie le fabricant de l'appareil |
| * |
| * @return le fabricant |
| */ |
| public String getMake() { |
| return renvoyerValeurCorrecte("ci_meta_make"); |
| } |
| /** |
| * Renvoie le modele de l'appareil |
| * |
| * @return le modele |
| */ |
| public String getModel() { |
| return renvoyerValeurCorrecte("ci_meta_model"); |
| } |
| /** |
| * Renvoie un tableau nom / valeur de toutes les metadonnées Iptc |
| * |
| * @return les métadonnées iptc |
| */ |
| public String[][] getMetadonnesIptc() { |
| String[][] metaIptc = new String[14][2]; |
| int elem = 0; |
| for (Iterator<String> it = this.keySet().iterator(); it.hasNext();) { |
| String key = it.next(); |
| // on filtre le "ci" |
| String type[] = key.split("_", 3); |
| // si c'est une metadonnee exif ou iptc |
| if (type[1].equals("meta")) { |
| String[] genre = type[2].split("_", 2); |
| if (genre[0].equals("iptc")) { |
| String nom = genre[1]; |
| metaIptc[elem][0] = nom; |
| metaIptc[elem][1] = renvoyerValeurCorrecte(key); |
| elem++; |
| } |
| } |
| } |
| return metaIptc; |
| } |
| /** |
| * Renvoie un tableau nom / valeur de toutes les metadonnées Exif |
| * |
| * @return les métadonnées Exif |
| */ |
| public String[][] getMetadonnesExif() { |
| String[][] metaExif = new String[31][2]; |
| int elem = 0; |
| for (Iterator<String> it = this.keySet().iterator(); it.hasNext();) { |
| String key = it.next(); |
| // on filtre le "ci" |
| String type[] = key.split("_", 3); |
| // si c'est une metadonnee exif ou iptc |
| if (type[1].equals("meta")) { |
| String[] genre = type[2].split("_", 2); |
| if (genre[0].equals("exif")) { |
| String nom = genre[1]; |
| metaExif[elem][0] = nom; |
| metaExif[elem][1] = renvoyerValeurCorrecte(key); |
| elem++; |
| } |
| } |
| } |
| return metaExif; |
| } |
| /** |
| * Renvoie un tableau nom / valeur contenant les infos générales |
| * |
| * @return les infos générales |
| */ |
| public String[][] getInfoGenerales() { |
| String[][] metaGen = new String[2][2]; |
| metaGen[0][0] = "ci_meta_comment"; |
| metaGen[0][1] = this.renvoyerValeurCorrecte("ci_meta_comment"); |
| metaGen[1][0] = "ci_meta_date"; |
| metaGen[1][1] = this.renvoyerValeurCorrecte("ci_meta_date"); |
| return metaGen; |
| } |
| /** |
| * Renvoie une string contenant les mots clés séparés par des ',' |
| * |
| * @return les mots clés |
| */ |
| public String getMotsCles() { |
| return renvoyerValeurCorrecte("ci_meta_mots_cles"); |
| } |
| /** |
| * Met à jour le commenentaire et la date |
| * |
| * @param commentaires |
| * le nouveau commentaire |
| * @param date |
| * la nouvelle date |
| */ |
| public void miseAJourInfoGenerales(String commentaires, String date, |
| String note) { |
| put("ci_meta_comment", commentaires); |
| put("ci_note_image", note); |
| put("ci_meta_date", date); |
| } |
| /** |
| * Met à jour les mots clés |
| * |
| * @param motsClesEnCours |
| * la liste de mots clés séparés par des ',' |
| */ |
| public void mettreAjourMotsCles(String motsClesEnCours) { |
| put("ci_meta_mots_cles", motsClesEnCours); |
| } |
| /** |
| * Accesseur pour le nom original |
| * |
| * @return le nom orginal de l'image |
| */ |
| public String getNomOriginal() { |
| return renvoyerValeurCorrecte("ci_nom_original"); |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/UtilisateurAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,188 |
| package org.tela_botanica.client.modeles; |
| /** |
| * Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour |
| * |
| */ |
| import org.tela_botanica.client.CarnetEnLigneModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| 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.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONBoolean; |
| 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.HTTPRequest; |
| import com.google.gwt.user.client.ResponseTextHandler; |
| public class UtilisateurAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO |
| */ |
| private CarnetEnLigneModele carnetEnLigneModele = null ; |
| /** |
| * Constructeur |
| */ |
| public UtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) { |
| this.carnetEnLigneModele=carnetEnLigneModele; |
| } |
| /** |
| * Methode de classe d'appel du service gestion identification |
| * @param baseURL : URL du service |
| * @param retour : methode appelle en retour d'appel |
| */ |
| public void getEtatUtilisateur(final Rafraichissable r) { |
| // Recherche identifiant utilisateur identifie |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,Configuration.getServiceBaseUrl() + "/User/") ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONArray jsonArray; |
| if ((jsonArray = jsonValue.isArray()) != null) { |
| String identifiant = ((JSONString) jsonArray.get(0)) |
| .stringValue(); // Identifiant utilisateur ou |
| // identifiant de session si non |
| // identifie |
| boolean identifie = ((JSONBoolean) jsonArray.get(1)) |
| .booleanValue(); // Drapeau leve si utilisateur |
| // deja identifie |
| boolean isAdmin = ((JSONBoolean) jsonArray.get(2)) |
| .booleanValue(); // Drapeau leve si utilisateur |
| // est admin |
| r.rafraichir(new Utilisateur(identifiant, identifie, isAdmin),true); |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void deconnecterUtilisateur(final Rafraichissable r, String user) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl()+ "/User/" + user) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONArray jsonArray; |
| if ((jsonArray = jsonValue.isArray()) != null) { |
| String identifiant = ((JSONString) jsonArray.get(0)) |
| .stringValue(); // Identifiant utilisateur ou |
| // identifiant de session si non |
| // identifie |
| boolean identifie = ((JSONBoolean) jsonArray.get(1)) |
| .booleanValue(); // Drapeau leve si utilisateur |
| // deja identifie |
| r.rafraichir(new Utilisateur(identifiant, identifie),true); |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void connecteUtilisateur (final Rafraichissable r, String login, String password) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,Configuration.getServiceBaseUrl() + "/User/" + login + "/" + password) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONArray jsonArray; |
| if ((jsonArray = jsonValue.isArray()) != null) { |
| String identifiant = ((JSONString) jsonArray.get(0)) |
| .stringValue(); // Identifiant utilisateur ou |
| // identifiant de session si non |
| // identifie |
| boolean identifie = ((JSONBoolean) jsonArray.get(1)) |
| .booleanValue(); // Drapeau leve si utilisateur |
| // deja identifie |
| boolean isAdmin = ((JSONBoolean) jsonArray.get(2)) |
| .booleanValue(); // Drapeau leve si utilisateur |
| // est admin |
| r.rafraichir(new Utilisateur(identifiant, identifie, isAdmin),true); |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| e.printStackTrace() ; |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ReferentielCommune.java |
|---|
| New file |
| 0,0 → 1,47 |
| package org.tela_botanica.client.modeles; |
| /** |
| * |
| * Classe representant un element du referentiel commune ou localite |
| * |
| */ |
| public class ReferentielCommune { |
| private String commune=null; |
| private String departement=null; |
| public ReferentielCommune() { |
| } |
| /** |
| * @param commune |
| * @param departement |
| */ |
| public ReferentielCommune(String commune, String departement) { |
| this.commune = commune; |
| this.departement = departement; |
| } |
| public String getCommune() { |
| return commune; |
| } |
| public String getDepartement() { |
| return departement; |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeUtilisateurAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,74 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.CarnetEnLigneModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| 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.json.client.JSONArray; |
| 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.Window; |
| public class ListeUtilisateurAsynchroneDAO { |
| CarnetEnLigneModele cModele = null ; |
| public ListeUtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) { |
| cModele = carnetEnLigneModele ; |
| } |
| public final void obtenirListeUtilisateur(final Rafraichissable r,final String rech, final String utilisateur) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() + "/InventoryUserList/" + utilisateur+"/"+rech); |
| 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) { |
| String[][] util ; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = responseValue.isArray(); |
| if(reponse != null) { |
| util = new String[reponse.size()][1]; |
| for(int i = 0; i < reponse.size() ; i++) { |
| JSONString item = reponse.get(i).isString(); |
| if(item != null) { |
| util[i][0] = item.stringValue(); |
| } |
| } |
| } |
| else { |
| util = new String[0][1]; |
| } |
| r.rafraichir(util, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeReferentielCommune.java |
|---|
| New file |
| 0,0 → 1,53 |
| package org.tela_botanica.client.modeles; |
| import java.util.HashMap; |
| /** |
| * table de hachage composée de communes, renvoyé par les objets de type DAO |
| * pour les communes |
| * TODO : utiliser un identifiant commune |
| * La clé est le nom de la commune + l'identifiant du departement de la commune dans la base de données, et la valeur un objet |
| * de type ReferentielCommune |
| * @author david delon |
| * |
| */ |
| public class ListeReferentielCommune extends HashMap<String, ReferentielCommune> { |
| private static final long serialVersionUID = 2714510270773281540L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeReferentielCommune() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeReferentielCommune(int taille) |
| { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param ic un tableau d'ImageCarnet |
| */ |
| public ListeReferentielCommune(ReferentielCommune[] com) |
| { |
| super() ; |
| for (int i = 0; i < com.length; i++) |
| { |
| if(com[i] != null && com[i] instanceof ReferentielCommune) |
| { |
| this.put(com[i].getCommune()+com[i].getDepartement(),com[i]); |
| } |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/DateObservation.java |
|---|
| New file |
| 0,0 → 1,59 |
| package org.tela_botanica.client.modeles; |
| import com.google.gwt.user.client.Window; |
| /** |
| * |
| * Classe representant une entite geographique (localite, commune, lieu dit) presente dans la liste des observations |
| * |
| */ |
| public class DateObservation { |
| private String annee=null; |
| private String mois=null; |
| private String jour=null; |
| public DateObservation() { |
| // TODO Auto-generated constructor stub |
| } |
| /** |
| * @param commune |
| * @param departement |
| */ |
| public DateObservation(String date) { |
| String dateTab[] = date.split(" ") ; |
| String dateSpl[] = dateTab[0].split("-") ; |
| annee= dateSpl[0]; |
| mois= dateSpl[1]; |
| jour= dateSpl[2]; |
| } |
| public String getAnnee() { |
| return annee; |
| } |
| public String getMois() { |
| return mois; |
| } |
| public String getJour() { |
| return jour; |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/Observation.java |
|---|
| New file |
| 0,0 → 1,265 |
| package org.tela_botanica.client.modeles; |
| public class Observation { |
| private String transmis=null; |
| private String nomSaisi=null; |
| private String nomRetenu=null; |
| private String numeroNomenclaturalSaisi=null; |
| private String numeroNomenclaturalRetenu=null; |
| private String numeroTaxonomique=null; |
| private String famille=null; |
| private String localite=null; |
| private String identifiantLocalite=null; |
| private String lieudit=null; |
| private String station=null; |
| private String milieu=null; |
| private String commentaire=null; |
| private String date=null; |
| private String numeroOrdre=null; |
| private String motsCles=null; |
| public Observation() { |
| } |
| /** |
| * Une observation telle que stockee dans la base de donnee |
| * |
| * @param transmis |
| * @param nomSaisi |
| * @param nomRetenu |
| * @param numeroNomenclaturalSaisi |
| * @param numeroNomenclaturalRetenu |
| * @param numeroTaxonomique |
| * @param famille |
| * @param localite |
| * @param IdentifiantLocalite |
| * @param lieudit |
| * @param station |
| * @param milieu |
| * @param commentaire |
| * @param date |
| * @param numeroOrdre |
| */ |
| public Observation(String transmis, String nomSaisi, String nomRetenu, String numeroNomenclaturalSaisi, String numeroNomenclaturalRetenu, String numeroTaxonomique, String famille, String localite, String identifiantLocalite, String lieudit, String station, String milieu, String commentaire, String date, String numeroOrdre) { |
| this.transmis = transmis; |
| this.nomSaisi = nomSaisi; |
| this.nomRetenu = nomRetenu; |
| this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi; |
| this.numeroNomenclaturalRetenu = numeroNomenclaturalRetenu; |
| this.numeroTaxonomique = numeroTaxonomique; |
| this.famille = famille; |
| this.identifiantLocalite = identifiantLocalite; |
| this.lieudit = lieudit; |
| this.station = station; |
| this.milieu = milieu; |
| this.commentaire = commentaire; |
| this.date = date; |
| this.numeroOrdre = numeroOrdre; |
| // Suppresion indication departementale (on pourrait faire mieux !!) |
| int pos=localite.indexOf(" (" ); |
| if (pos>=0) { |
| this.localite=localite.substring(0,pos); |
| } |
| else { |
| this.localite=localite; |
| } |
| this.motsCles = ""; |
| } |
| /** |
| * Une observation telle que stockee dans la base de donnee avec les mots clés |
| * |
| * @param transmis |
| * @param nomSaisi |
| * @param nomRetenu |
| * @param numeroNomenclaturalSaisi |
| * @param numeroNomenclaturalRetenu |
| * @param numeroTaxonomique |
| * @param famille |
| * @param localite |
| * @param IdentifiantLocalite |
| * @param lieudit |
| * @param station |
| * @param milieu |
| * @param commentaire |
| * @param date |
| * @param numeroOrdre |
| * @param motsCles |
| */ |
| public Observation(String transmis, String nomSaisi, String nomRetenu, String numeroNomenclaturalSaisi, String numeroNomenclaturalRetenu, String numeroTaxonomique, String famille, String localite, String identifiantLocalite, String lieudit, String station, String milieu, String commentaire, String date, String numeroOrdre, String motsCles) { |
| this.transmis = transmis; |
| this.nomSaisi = nomSaisi; |
| this.nomRetenu = nomRetenu; |
| this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi; |
| this.numeroNomenclaturalRetenu = numeroNomenclaturalRetenu; |
| this.numeroTaxonomique = numeroTaxonomique; |
| this.famille = famille; |
| this.identifiantLocalite = identifiantLocalite; |
| this.lieudit = lieudit; |
| this.station = station; |
| this.milieu = milieu; |
| this.commentaire = commentaire; |
| this.date = date; |
| this.numeroOrdre = numeroOrdre; |
| // Suppresion indication departementale (on pourrait faire mieux !!) |
| int pos=localite.indexOf(" (" ); |
| if (pos>=0) { |
| this.localite=localite.substring(0,pos); |
| } |
| else { |
| this.localite=localite; |
| } |
| this.motsCles = motsCles; |
| } |
| /** |
| * Une observation saisie ou modifiee |
| * |
| * @param nomSaisi |
| * @param numeroNomenclaturalSaisi |
| * @param localite |
| * @param IdentifiantLocalite |
| * @param lieudit |
| * @param station |
| * @param milieu |
| * @param commentaire |
| * @param date |
| * |
| */ |
| public Observation(String nomSaisi, String numeroNomenclaturalSaisi, String localite, String identifiantLocalite, String lieudit, String station, String milieu, String commentaire, String date) { |
| this.nomSaisi = nomSaisi; |
| this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi; |
| this.identifiantLocalite = identifiantLocalite; |
| this.lieudit = lieudit; |
| this.station = station; |
| this.milieu = milieu; |
| this.commentaire = commentaire; |
| this.date = date; |
| // Suppresion indication departementale (on pourrait faire mieux !!) |
| if(localite != null) { |
| int pos=localite.indexOf(" (" ); |
| if (pos>=0) { |
| this.localite=localite.substring(0,pos); |
| } |
| else { |
| this.localite=localite; |
| } |
| } |
| this.motsCles = "" ; |
| } |
| public String getNomSaisi() { |
| return nomSaisi; |
| } |
| public String getNumeroOrdre() { |
| return numeroOrdre; |
| } |
| public String getCommentaire() { |
| return commentaire; |
| } |
| public String getDate() { |
| return date; |
| } |
| public String getFamille() { |
| return famille; |
| } |
| public String getLieudit() { |
| return lieudit; |
| } |
| public String getLocalite() { |
| return localite; |
| } |
| public String getIdentifiantLocalite() { |
| return identifiantLocalite; |
| } |
| public String getMilieu() { |
| return milieu; |
| } |
| public String getNomRetenu() { |
| return nomRetenu; |
| } |
| public String getNumeroNomenclaturalSaisi() { |
| return numeroNomenclaturalSaisi; |
| } |
| public String getNumeroNomenclaturalRetenu() { |
| return numeroNomenclaturalRetenu; |
| } |
| public String getNumeroTaxonomique() { |
| return numeroTaxonomique; |
| } |
| public String getStation() { |
| return station; |
| } |
| public String getTransmis() { |
| return transmis; |
| } |
| public String getMotsCles() { |
| return motsCles; |
| } |
| public void setMotsCles(String motsCles) { |
| this.motsCles = motsCles; |
| } |
| public void setNumeroOrdre(String numeroOrdre) { |
| this.numeroOrdre = numeroOrdre; |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/MotsClesObsAsynchronesDAO.java |
|---|
| New file |
| 0,0 → 1,127 |
| package org.tela_botanica.client.modeles; |
| import java.util.Iterator; |
| import java.util.Set; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.Window; |
| public class MotsClesObsAsynchronesDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele oModele = null; |
| public MotsClesObsAsynchronesDAO(ObservationModele om) { |
| oModele = om; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param im |
| * le modèle à associer |
| */ |
| public void setIModele(ObservationModele om) { |
| oModele = om; |
| } |
| public void obtenirMotsClesObservations(final Rafraichissable r) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordObsList/" + oModele.getIdentifiant()); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si la requête est un succès on reçoit un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| int tailleMaxMotCle = (int) reponse.get(0).isNumber().doubleValue() ; |
| r.rafraichir(tailleMaxMotCle, false); |
| // et on met à jour le demandeur des données |
| JSONObject motClesPoids = reponse.get(1).isObject(); |
| int nbMotsCles = motClesPoids.size(); |
| Object[][] tabMotsCles = new Object[nbMotsCles][2]; |
| Set<String> im = motClesPoids.keySet(); |
| int i = 0; |
| // on la parcourt pour chaque clé |
| for (Iterator<String> iterator = im.iterator(); iterator.hasNext();) { |
| String key = iterator.next(); |
| tabMotsCles[i][0] = key; |
| tabMotsCles[i][1] = (int)motClesPoids.get(key).isNumber().doubleValue(); |
| i++; |
| } |
| r.rafraichir(tabMotsCles, false); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void ajouterMotsCles(final Rafraichissable r, String numObsApl, |
| String motsAAjouter) { |
| String post = "motscles="+motsAAjouter+"&idsobs="+numObsApl; |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordObsList/" + oModele.getIdentifiant()); |
| try { |
| rb.sendRequest(post, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if(response.getText().equals("OK")) { |
| r.rafraichir("OK", true); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,174 |
| package org.tela_botanica.client.modeles; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageModele; |
| 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; |
| /** |
| * DAO d'accès à une image, n'est utilisé que pour l'écriture et pas pour la |
| * lecture des images qui se fait par paquet |
| * |
| * @author aurelien |
| * |
| */ |
| public class ImageAsynchroneDAO { |
| ImageModele iModele = null; |
| public ImageAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Met à jour la base de données avec toutes les données d'une image |
| * |
| * @param ic |
| * l'image à mettre à jour |
| */ |
| public void SynchroniserBaseDeDonnees(final ImageCarnet ic) { |
| String postData = ""; |
| // on construit le post avec toutes les valeur de l'image |
| for (Iterator<String> imgIt = ic.keySet().iterator(); imgIt.hasNext();) { |
| String key = imgIt.next(); |
| String valeur = ic.renvoyerValeurCorrecte(key); |
| postData += "&" + key + "=" + valeur; |
| } |
| // et on envoie une requête asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele |
| .getConfig().getServiceBaseUrl() |
| + "/inventoryImage/" + iModele.getIdentifiant() + "/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| /** |
| * Met à jour la base de données avec les mots clés associés à l'image |
| * |
| * @param ic |
| * l'image à mettre à jour |
| */ |
| public void SynchroniserMotsClesImageBaseDeDonnees(final ImageCarnet ic) { |
| String postData = ""; |
| // on récupère les mots clés de l'image et on fabrique le post |
| String motsCles = ic.getMotsCles(); |
| String id = ic.getId(); |
| postData += "&ci_id_image=" + id + "&ci_meta_mots_cles=" + motsCles; |
| // on envoie une requête asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventoryImage/" + iModele.getIdentifiant() + "/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| /** |
| * Supprime une image de la base de données |
| * |
| * @param ic |
| * l'image à supprimer |
| */ |
| public void supprimerBaseDeDonnees(final ImageCarnet ic) { |
| // le post contient l'action delete pour JREST (qui ne gère pas DELETE |
| // comme une requête à part entière) |
| String postData = ""; |
| postData += "&action=DELETE"; |
| // on envoie un post avec l'id de l'image à supprimer |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele |
| .getConfig().getServiceBaseUrl() |
| + "/inventoryImage/" |
| + iModele.getIdentifiant() |
| + "/" |
| + ic.getId()); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données : "+response.getText()); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,249 |
| package org.tela_botanica.client.modeles; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| 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.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * Data Object Access communiquant avec le serveur jrest fournissant la liste |
| * des images répondant à des critères donné |
| * |
| * @author aurelien |
| * |
| */ |
| public class ListeImageAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO |
| */ |
| ImageModele iModele = null; |
| public ListeImageAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param im |
| * le modèle à associer |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir une liste d'images |
| * correspondant à des critères demandés |
| * |
| * @param r |
| * le rafraichissable qui a demandé les données |
| * @param criteres |
| * un tableau contenant les critères de selections |
| */ |
| public void ObtenirListeImages(final Rafraichissable r, String[][] criteres) { |
| String requete = ""; |
| // on construit les paramètres du get |
| if (criteres != null) { |
| for (int i = 0; i < criteres.length; i++) { |
| if (!criteres[i][1].equals("")) { |
| if (i != 0) { |
| requete += "&"; |
| } |
| requete += criteres[i][0] + "=" + criteres[i][1]; |
| } |
| } |
| } |
| // on envoie le get asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele |
| .getConfig().getServiceBaseUrl() |
| + "/InventoryImageList/" |
| + iModele.getIdentifiant() |
| + "/" |
| + requete); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| final ListeImageCarnet photoData; |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si c'est un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| final int taillemax = reponse.size(); |
| photoData = new ListeImageCarnet(taillemax); |
| // on le parcourt |
| for (int j = 0; j < taillemax; j++) { |
| JSONObject image = (JSONObject) reponse.get(j); |
| ImageCarnet im = new ImageCarnet(image); |
| // et on en extrait les données pour construire la |
| // liste d'image |
| photoData.put(im.getOrdre(), im); |
| } |
| } else { |
| // si c'est un objet alors il n'y a qu'une réponse |
| if (responseValue.isObject() != null) { |
| photoData = new ListeImageCarnet(1); |
| ImageCarnet im = new ImageCarnet(responseValue |
| .isObject()); |
| // on crée une liste de 1 élement auquel on ajoute |
| // ce qui a été reçu |
| photoData.put(im.getOrdre(), im); |
| } else { |
| // sinon on crée une liste vide |
| photoData = new ListeImageCarnet(0); |
| } |
| } |
| // dans tous les cas on transmet la liste crée au |
| // rafraichissable en lui demandant de répandre les données |
| // car il est |
| // le premier à les recevoir |
| r.rafraichir(photoData, true); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| /** |
| * Met à jour les valeurs d'une liste d'image donnée dans la base de données |
| * |
| * @param li |
| * la liste d'image à synchroniser avec la base |
| */ |
| public void SynchroniserBaseDeDonnees(ListeImageCarnet li) { |
| // on parcourt toute la liste d'image |
| for (Iterator<String> listIt = li.keySet().iterator(); listIt.hasNext();) { |
| String postData = ""; |
| ImageCarnet enCours = li.get(listIt.next()); |
| // pour chaque image on extrait les informations |
| for (Iterator<String> imgIt = enCours.keySet().iterator(); imgIt |
| .hasNext();) { |
| // qu'on place dans le poste |
| String key = imgIt.next(); |
| String valeur = enCours.renvoyerValeurCorrecte(key); |
| valeur.replaceAll("'", "\'"); |
| postData += "&" + key + "=" |
| + enCours.renvoyerValeurCorrecte(key); |
| } |
| // on fait un post asynchrone et on les envoie à jrest |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventoryImage/" + iModele.getIdentifiant() + "/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| return; |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * Supprime des image sur le serveur par rapport à leur identifant |
| * |
| * @param ids |
| * un tableau d'identifiants d'images à supprimer |
| */ |
| public void supprimerBaseDeDonnees(String[] ids) { |
| String postData = ""; |
| // on fait un delete dans le post (jrest ne gère pas delete comme une |
| // action à part entière) |
| postData += "&action=DELETE"; |
| String uid = ""; |
| // on concatène les ids |
| for (int i = 0; i < ids.length; i++) { |
| uid += ids[i] + ","; |
| } |
| // et on envoie ça au serveur |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, Configuration.getServiceBaseUrl() |
| + "/inventoryImageList/" + iModele.getIdentifiant() + "/" + uid); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| // quand la requête est éxecutée on le signale au modèle |
| // poru qu'il mette à jour les données |
| // et en notifie le médiateur |
| iModele.requeteTerminee(); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ExportObservationsDAO.java |
|---|
| New file |
| 0,0 → 1,43 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.user.client.Window; |
| public class ExportObservationsDAO { |
| ObservationModele om = null ; |
| public ExportObservationsDAO(ObservationModele observationModele) { |
| om = observationModele ; |
| } |
| public void exporterObservations(String identifiant, String[][] criteres) { |
| String requete = "" ; |
| if(criteres != null) |
| { |
| // on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...) |
| for (int i = 0; i < criteres.length; i++) { |
| if(!criteres[i][1].equals("")) |
| { |
| if(i!= 0) |
| { |
| requete += "&"; |
| } |
| requete += criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ; |
| } |
| } |
| } |
| Window.open(Configuration.getServiceBaseUrl()+"/InventoryExport/"+identifiant+"/"+requete,"Export",null) ; |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeEntiteGeographiqueObservation.java |
|---|
| New file |
| 0,0 → 1,54 |
| package org.tela_botanica.client.modeles; |
| import java.util.LinkedHashMap; |
| /** |
| * table de hachage composée d'entite geographique, renvoyé par les objets de type DAO |
| * La clé est le nom de l'entite + le nom de l'entite parente |
| * |
| * @author david delon |
| * |
| */ |
| public class ListeEntiteGeographiqueObservation extends LinkedHashMap<String, EntiteGeographiqueObservation> { |
| private static final long serialVersionUID = 2717710270773281540L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeEntiteGeographiqueObservation() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeEntiteGeographiqueObservation(int taille) |
| { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param ic un tableau d'ImageCarnet |
| */ |
| public ListeEntiteGeographiqueObservation(EntiteGeographiqueObservation[] ent) |
| { |
| super() ; |
| for (int i = 0; i < ent.length; i++) |
| { |
| if(ent[i] != null && ent[i] instanceof EntiteGeographiqueObservation) |
| { |
| this.put(ent[i].getIdLocation()+ent[i].getLieuDit(),ent[i]); |
| } |
| } |
| } |
| public void put(EntiteGeographiqueObservation value) { |
| this.put(value.getIdLocation()+value.getLieuDit(),value); |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/NombreObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,107 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.HTTPRequest; |
| import com.google.gwt.user.client.ResponseTextHandler; |
| /** |
| * DAO qui renvoie le nombre d'image associées à différents critères donnés (utile pour la pagination) |
| * @author aurelien |
| * |
| */ |
| public class NombreObservationAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO |
| */ |
| private ObservationModele observationModele = null ; |
| public NombreObservationAsynchroneDAO(ObservationModele observationModele) |
| { |
| this.observationModele=observationModele; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir le nombre d'observation correspondant |
| * à des critères données en paramètres |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param criteres un tableau nom/valeur des critères pour les images |
| */ |
| public void obtenirNombreObservation(final Rafraichissable r, String utilisateur, String[][] criteres) |
| { |
| String requete = "" ; |
| if(criteres != null) |
| { |
| // on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...) |
| for (int i = 0; i < criteres.length; i++) { |
| if(!criteres[i][1].equals("") && criteres[i][1] != null) |
| { |
| if(i!= 0) |
| { |
| requete += "&"; |
| } |
| requete += criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ; |
| } |
| } |
| } |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,Configuration.getServiceBaseUrl()+"/InventoryObservationCount/"+utilisateur+"/"+requete) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| // si la requete se passe bien on reçoit un tableau JSON |
| if(responseValue.isArray() != null) |
| { |
| // qui contient une valeur : le nombre d'images correspondant au critères |
| JSONValue res = responseValue.isArray().get(0) ; |
| JSONString reponseNombre = res.isString() ; |
| int maxObservations = Integer.parseInt(reponseNombre.stringValue()) ; |
| int[] nbObservations = {maxObservations} ; |
| // on le met dans un tableau d'entiers qu'on tranmset au demandeur de la mise à jour |
| r.rafraichir(nbObservations, true) ; |
| } else { |
| int[] nbObservations = {} ; |
| r.rafraichir(nbObservations, true) ; |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeImageCarnet.java |
|---|
| New file |
| 0,0 → 1,54 |
| package org.tela_botanica.client.modeles; |
| import java.util.HashMap; |
| /** |
| * table de hachage composée d'ImageCarnet, renvoyé par les objets de type DAO |
| * pour les images. La clé est l'identifiant de l'image dans la base de données, |
| * et la valeur un objet de type ImageCarnet. GWT ne supporte pas encore les |
| * type paramètres mais quand il le fera il faudra créer la HashMap avec |
| * <String,ImageCarnet> |
| * |
| * @author aurelien |
| * |
| */ |
| public class ListeImageCarnet extends HashMap<String, ImageCarnet> { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 2715320270773281540L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeImageCarnet() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param taille |
| * la taille de la table de hachage |
| */ |
| public ListeImageCarnet(int taille) { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param ic |
| * un tableau d'ImageCarnet |
| */ |
| public ListeImageCarnet(ImageCarnet[] ic) { |
| super(); |
| for (int i = 0; i < ic.length; i++) { |
| if (ic[i] != null && ic[i] instanceof ImageCarnet) { |
| this.put(ic[i].getOrdre(), ic[i]); |
| } |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/TransmissionObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,66 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| 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.Window; |
| public class TransmissionObservationAsynchroneDAO { |
| ObservationModele om = null ; |
| public TransmissionObservationAsynchroneDAO(ObservationModele observationModele) { |
| om = observationModele ; |
| } |
| public void transmettreObservations(final Rafraichissable r, String identifiant, String idsObs, boolean publier) { |
| // on envoie le get asynchrone |
| String post = "&transmission="; |
| if(publier) { |
| post += "1"; |
| } |
| else |
| { |
| post += "0" ; |
| } |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl() |
| +"/InventoryTransmit/"+om.getIdentifiant()+"/"+idsObs) ; |
| try { |
| rb.sendRequest(post, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| r.rafraichir("OK",true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeEntiteGeographiqueObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,117 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.interfaces.FournisseurListe; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| 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.Window; |
| /** |
| * DAO la liste des communes. |
| * @author David Delon |
| * |
| */ |
| public class ListeEntiteGeographiqueObservationAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ObservationModele observationModele = null; |
| /** |
| * Constructeur. |
| * @param obs : Modele |
| */ |
| public ListeEntiteGeographiqueObservationAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele = obs; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres. |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param critere un string contenant le terme a rechercher |
| */ |
| public final void obtenirListeEntitesGeographiques(final Rafraichissable r, final String utilisateur) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() + "/InventoryLocationList/" + utilisateur); |
| 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) { |
| final ListeEntiteGeographiqueObservation listeEntiteGeographiqueObservation; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = null; |
| // si c'est un tableau |
| if ((reponse = responseValue.isArray()) != null) { |
| JSONArray entites; |
| final int taillemax = reponse.size(); |
| listeEntiteGeographiqueObservation = new ListeEntiteGeographiqueObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((entites = reponse.get(i).isArray()) != null) { |
| String localite = ((JSONString) entites.get(0)).stringValue(); |
| String commune = ((JSONString) entites.get(1)).stringValue(); |
| String lieuDit = ((JSONString) entites.get(2)).stringValue(); |
| EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(localite, commune, lieuDit); |
| listeEntiteGeographiqueObservation.put(ent); |
| } |
| } |
| } else { |
| listeEntiteGeographiqueObservation = new ListeEntiteGeographiqueObservation(0); |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| r.rafraichir(listeEntiteGeographiqueObservation, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ImageGeneriqueVueAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,85 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO d'accès a une observation |
| * |
| * @author aurelien |
| * |
| */ |
| public class ImageGeneriqueVueAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele observationModele = null; |
| public ImageGeneriqueVueAsynchroneDAO(ObservationModele obs) { |
| observationModele = obs; |
| } |
| /** |
| * Recherche Image repartition associee a un nom |
| * @param r |
| * @param identifiant |
| * @param numeroNomenclaturalSaisiObservation |
| */ |
| public void obtenirURLImage(final Rafraichissable r, String numeroNomenclaturalSaisiObservation) { |
| // on envoie le get asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,observationModele.getConfig().getServiceBaseUrl() |
| +"/NameImage/"+numeroNomenclaturalSaisiObservation) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse; |
| String urlImage=null; |
| if ((reponse = responseValue.isArray()) != null) { |
| // Url Image |
| urlImage= ((JSONString)reponse.get(0)).stringValue(); |
| } |
| else { |
| urlImage=""; |
| } |
| r.rafraichir(urlImage,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ImageInformationRepartitionAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,85 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO d'accès a une observation |
| * |
| * @author aurelien |
| * |
| */ |
| public class ImageInformationRepartitionAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele observationModele = null; |
| public ImageInformationRepartitionAsynchroneDAO(ObservationModele obs) { |
| observationModele = obs; |
| } |
| /** |
| * Recherche Image repartition associee a un nom |
| * @param r |
| * @param identifiant |
| * @param numeroNomenclaturalSaisiObservation |
| */ |
| public void obtenirURLImage(final Rafraichissable r, String numeroNomenclaturalSaisiObservation) { |
| // on envoie le get asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,observationModele.getConfig().getServiceBaseUrl() |
| +"/NameMap/"+numeroNomenclaturalSaisiObservation) ; |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse; |
| String urlImage=null; |
| if ((reponse = responseValue.isArray()) != null) { |
| // Url Image |
| urlImage= ((JSONString)reponse.get(0)).stringValue(); |
| } |
| else { |
| urlImage=""; |
| } |
| r.rafraichir(urlImage,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/NomRetenuAsynchroneDao.java |
|---|
| New file |
| 0,0 → 1,68 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.Util; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| 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.Window; |
| public class NomRetenuAsynchroneDao { |
| private ObservationModele oModele = null ; |
| public NomRetenuAsynchroneDao(ObservationModele observationModele) { |
| oModele = observationModele ; |
| } |
| public void obtenirNomRetenu(final Rafraichissable r, final String anum) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, |
| Configuration.getServiceBaseUrl() |
| + "/name/"+anum); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONArray jsonArray; |
| if ((jsonArray = jsonValue.isArray()) != null) { |
| String aname = Util.toCelString(((JSONString) jsonArray.get(0)).toString()); |
| // Nom |
| if (aname.compareTo("null")!=0) { |
| String[] numNom = {aname, anum } ; |
| r.rafraichir(numNom, false); |
| } |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeDateObservation.java |
|---|
| New file |
| 0,0 → 1,60 |
| package org.tela_botanica.client.modeles; |
| import java.util.LinkedHashMap; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.user.client.Window; |
| /** |
| * table de hachage composée d'entite geographique, renvoyé par les objets de type DAO |
| * La clé est le nom de l'entite + le nom de l'entite parente |
| * |
| * @author david delon |
| * |
| */ |
| public class ListeDateObservation extends LinkedHashMap<String, DateObservation> { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 6057292016502553510L; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ListeDateObservation() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeDateObservation(int taille) |
| { |
| super(taille); |
| } |
| public ListeDateObservation(JSONArray dates) |
| { |
| super(dates.size()) ; |
| final int taillemax = dates.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONArray dateEncours = dates.get(i).isArray() ; |
| if(dateEncours != null) |
| { |
| String dateString = ((JSONString)dateEncours.get(0)).stringValue() ; |
| DateObservation dat = new DateObservation(dateString); |
| this.put(dateString,dat); |
| } |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeObservation.java |
|---|
| New file |
| 0,0 → 1,62 |
| package org.tela_botanica.client.modeles; |
| import java.util.LinkedHashMap; |
| /** |
| * table de hachage composée d'observation, renvoyé par les objets de type DAO |
| * pour les images. |
| * La clé est l'identifiant de l'observation dans la base de données, et la valeur un objet |
| * de type Observation |
| * |
| * L'uitilisation de LinkedHashMap permet de conserver l'ordre d'insertion des elements à la lecture |
| * @author david delon |
| * |
| */ |
| public class ListeObservation extends LinkedHashMap<String, Observation>{ |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 2715320270773281540L; |
| /* |
| * Constructeur sans paramètres |
| */ |
| public ListeObservation() |
| { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ListeObservation(int taille) |
| { |
| super(taille); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param ic un tableau d'ImageCarnet |
| */ |
| public ListeObservation(Observation[] obs) |
| { |
| super() ; |
| for (int i = 0; i < obs.length; i++) |
| { |
| if(obs[i] != null && obs[i] instanceof Observation) |
| { |
| this.put(obs[i].getNumeroOrdre(),obs[i]); |
| } |
| } |
| } |
| public void ajouterObservation(Observation obs) { |
| if(obs != null) |
| { |
| this.put(obs.getNumeroOrdre(),obs); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ImageUploaderAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,163 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.image.ImageModele; |
| import com.gwtext.client.core.UrlParam; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.WindowListenerAdapter; |
| import com.gwtextux.client.widgets.upload.UploadDialog; |
| import com.gwtextux.client.widgets.upload.UploadDialogListenerAdapter; |
| /** |
| * DAO un peu particulier car il crée une fenetre d'upload différente suivant |
| * que le plugin Java est détecté ou non |
| * |
| * |
| */ |
| public class ImageUploaderAsynchroneDAO { |
| /** |
| * Modele associé au DAO |
| */ |
| private static ImageModele iModele; |
| public ImageUploaderAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Setteur pour le modele |
| * |
| * @param im |
| * le modèle à associer au DAO |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Crée un panel d'upload simple aux fonctions réduites mais utilisant |
| * uniquement javascript (pour les utilisateurs qui n'ont pas java) |
| */ |
| @SuppressWarnings("unused") |
| public static void appelerUploadSimple() { |
| UploadDialog up = new UploadDialog("Upload simple de fichiers"); |
| up.setUrl(Configuration.getServiceBaseUrl() + "/InventoryImage"); |
| UrlParam id = new UrlParam("identifiant", iModele.getIdentifiant()); |
| UrlParam[] params = { id }; |
| up.setBaseParams(params); |
| up.setModal(true); |
| up.addListener(new UploadDialogListenerAdapter() { |
| public void onClose(Panel panel) { |
| iModele.requeteTerminee(); |
| } |
| public void onUploadComplete(UploadDialog source) { |
| iModele.requeteTerminee(); |
| } |
| }); |
| up.show(); |
| } |
| /** |
| * Crée une fenêtre contenant une applet java pour uploader plusieurs |
| * fichiers à la fois avec quelques fonctions avancées (nécessite le plugin |
| * java pour le navigateur) |
| */ |
| @SuppressWarnings("unused") |
| public static void appelerUploadMultiple() { |
| final Window nPan = new Window("Upload multiple"); |
| nPan.setWidth(640); |
| final String warning = "<p class=\"warning_upload\"> A la fin de l'envoi, veuillez fermer la fenêtre pour accéder aux images. </p>"; |
| final String applet = "<applet code=\"wjhk.jupload2.JUploadApplet\" archive=\"wjhk.jupload.jar\" alt=\"\" mayscript=\"\" height=\"350\" width=\"625\">"; |
| final String paramPostTarget = "<param name=\"postURL\" value=\"" |
| + Configuration.getServiceBaseUrl() |
| + "/InventoryImage/\">"; |
| final String paramUploadPolicy = "<param name=\"uploadPolicy\" value=\"PictureUploadPolicy\">"; |
| final String paramMaxChunkSize = "<param name=\"maxChunkSize\" value=\"0\">"; |
| final String paramMaxFileSize = "<param name=\"maxFileSize\" value=\"10000000\">"; |
| final String paramTransmitMetaData = "<param name=\"pictureTransmitMetadata\" value=\"true\">"; |
| final String paramFilesPerRequest = "<param name=\"nbFilesPerRequest\" value=\"1\">"; |
| final String paramAllowedExtensions = "<param name=\"allowedFileExtensions\" value=\"jpg/jpeg/\">"; |
| final String paramUploadSuccess = "<param name=\"stringUploadSuccess\" value=\"OK\">"; |
| final String paramShowLogWindow = "<param name=\"showLogWindow\" value=\"false\">"; |
| final String paramFormdata = "<param name=\"formData\" value=\"postid\">"; |
| final String finApplet = "</applet>"; |
| final String appelApplet = applet + paramPostTarget + paramUploadPolicy |
| + paramMaxChunkSize + paramMaxFileSize + paramTransmitMetaData |
| + paramFilesPerRequest + paramAllowedExtensions |
| + paramUploadSuccess + paramShowLogWindow + paramFormdata |
| + finApplet; |
| final String htmlForm = "<form method=\"post\" name=\"postid\">" |
| + "<input type=\"hidden\" name=\"identifiant\" value=\"" |
| + iModele.getIdentifiant() + "\">" + "</form>"; |
| nPan.setHtml(warning + appelApplet + htmlForm); |
| nPan.setModal(true); |
| nPan.addListener(new WindowListenerAdapter() { |
| public void onClose(Panel panel) { |
| iModele.requeteTerminee(); |
| } |
| }); |
| nPan.show(); |
| } |
| /** |
| * Fonction javascript native qui détecte la présence du plugin java pour le |
| * navigateur et appelle la méthode d'upload adaptée (appelerUploadSimple ou |
| * appelerUploadMultiple) |
| */ |
| public static native void choisirMethodeUpload() /*-{ |
| var agt=navigator.userAgent.toLowerCase(); |
| var ie = (agt.indexOf("msie") != -1); |
| var ns = (navigator.appName.indexOf("Netscape") != -1); |
| var win = ((agt.indexOf("win")!=-1) || (agt.indexOf("32bit")!=-1)); |
| var mac = (agt.indexOf("mac")!=-1); |
| function detectIE(ClassID,name) { result = false; document.write('<SCRIPT LANGUAGE=VBScript>\n on error resume next \n result = IsObject(CreateObject("' + ClassID + '"))</SCRIPT>\n'); if (result) return name+','; else return ''; } |
| function detectNS(ClassID,name) { n = ""; if (nse.indexOf(ClassID) != -1) if (navigator.mimeTypes[ClassID].enabledPlugin != null) n = name+","; return n; } |
| if (ie && win) { pluginlist = detectIE("Adobe.SVGCtl","SVG Viewer") + detectIE("SWCtl.SWCtl.1","Shockwave Director") + detectIE("ShockwaveFlash.ShockwaveFlash.1","Shockwave Flash") + detectIE("rmocx.RealPlayer G2 Control.1","RealPlayer") + detectIE("QuickTimeCheckObject.QuickTimeCheck.1","QuickTime") + detectIE("MediaPlayer.MediaPlayer.1","Windows Media Player") + detectIE("PDF.PdfCtrl.5","Acrobat Reader"); } |
| if (ns || !win) { |
| nse = ""; for (var i=0;i<navigator.mimeTypes.length;i++) nse += navigator.mimeTypes[i].type.toLowerCase(); |
| pluginlist = detectNS("image/svg-xml","SVG Viewer") + detectNS("application/x-director","Shockwave Director") + detectNS("application/x-shockwave-flash","Shockwave Flash") + detectNS("audio/x-pn-realaudio-plugin","RealPlayer") + detectNS("video/quicktime","QuickTime") + detectNS("application/x-mplayer2","Windows Media Player") + detectNS("application/pdf","Acrobat Reader"); |
| } |
| pluginlist += navigator.javaEnabled() ? "Java," : ""; |
| if (pluginlist.length > 0) pluginlist = pluginlist.substring(0,pluginlist.length-1); |
| if(pluginlist.indexOf("Java")!=-1) |
| { |
| @org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO::appelerUploadMultiple()() ; |
| } |
| else |
| { |
| @org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO::appelerUploadSimple()() ; |
| } |
| }-*/; |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeReferentielNomAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,171 |
| package org.tela_botanica.client.modeles; |
| import java.util.HashMap; |
| import org.tela_botanica.client.Util; |
| import org.tela_botanica.client.interfaces.FournisseurListe; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO liste noms scientifiques // utilisation d'un cahce memoire pour eviter des requetes inutiles. |
| * @author David Delon |
| * |
| */ |
| public class ListeReferentielNomAsynchroneDAO implements FournisseurListe { |
| //TODO : limiter taille du cache ? (si pb performance) |
| /** |
| * Le modèle associé au DAO |
| */ |
| private ObservationModele observationModele = null ; |
| /** |
| * Cache |
| * |
| */ |
| private HashMap <String,ListeReferentielNom> cache = new HashMap(); |
| public ListeReferentielNomAsynchroneDAO(ObservationModele observationModele) |
| { |
| this.observationModele=observationModele; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param criteres un string contenant le terme a rechercher |
| */ |
| public void obtenirListeDonnees(final Rafraichissable r, final String critere) |
| { |
| ListeReferentielNom referentielNomDataFromCache=null; |
| // En cache ? |
| if ((referentielNomDataFromCache=getFromCache(critere))!=null) { |
| r.rafraichir(referentielNomDataFromCache,true); |
| } |
| else { |
| // On vérifie si un genre et une espèce sont demandées |
| // et ajoute le / manuellement car sinon il devient urlencode |
| String[] criteres =critere.split("/"); |
| String urlParams = "/NameSearch/"; |
| if(criteres.length > 1) { |
| String critere1 = criteres[0]; |
| String critere2 = criteres[1]; |
| urlParams += URL.encode(critere1)+"/"+URL.encode(critere2); |
| } else { |
| urlParams += URL.encode(critere); |
| } |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl()+urlParams); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| final ListeReferentielNom 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 ListeReferentielNom(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((noms=reponse.get(i).isArray()) != null) { |
| String nom=Util.toCelString(((JSONString) noms.get(0)).toString()); |
| String numeroNom=Util.toCelString(((JSONString) noms.get(1)).toString()); |
| ReferentielNom nomScientifique=new ReferentielNom(nom, numeroNom); |
| // FIXME : et si le numero de nom n'est pas unique ? (cas de multirefrentiel....) |
| referentielNomData.put(nomScientifique.getNumeroNom(),nomScientifique); |
| } |
| } |
| } else { |
| referentielNomData = new ListeReferentielNom(0) ; |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| addToCache(critere, referentielNomData); |
| r.rafraichir(referentielNomData,true); |
| } |
| }) ; |
| } catch(RequestException e) { |
| } |
| } // fin else si pas de cache |
| } |
| private void addToCache(String query, ListeReferentielNom result) { |
| cache.put(query.toLowerCase(),result); |
| } |
| private ListeReferentielNom getFromCache (String query) { |
| return (ListeReferentielNom) cache.get(query.toLowerCase()); |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/NombreImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,112 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| 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.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO qui renvoie le nombre d'image associées à différents critères donnés |
| * (utile pour la pagination) |
| * |
| * @author aurelien |
| * |
| */ |
| public class NombreImageAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO |
| */ |
| private ImageModele iModele = null; |
| public NombreImageAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param im |
| * le modèlme à associer |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir le nombre d'images |
| * correspondant à des critères données en paramètres |
| * |
| * @param r |
| * le rafraichissable qui demande la mise à jour |
| * @param criteres |
| * un tableau nom/valeur des critères pour les images |
| */ |
| public void obtenirNombreImages(final Rafraichissable r, String[][] criteres) { |
| String requete = ""; |
| if (criteres != null) { |
| // on construit les paramètres du get avec les critères |
| // (&critere1=valeur1&critere2=valeur2 etc...) |
| for (int i = 0; i < criteres.length; i++) { |
| if (!criteres[i][1].equals("")) { |
| if (i != 0) { |
| requete += "&"; |
| } |
| requete += criteres[i][0] + "=" + criteres[i][1]; |
| } |
| } |
| } |
| // on fait un get asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() |
| + "/InventoryImageCount/" |
| + iModele.getIdentifiant() |
| + "/" |
| + requete); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si la requete se passe bien on reçoit un tableau JSON |
| if (responseValue.isArray() != null) { |
| // qui contient une valeur : le nombre d'images |
| // correspondant au critères |
| JSONValue res = responseValue.isArray().get(0); |
| JSONString reponseNombre = res.isString(); |
| int maxImages = Integer.parseInt(reponseNombre |
| .stringValue()); |
| int[] nbImages = { maxImages }; |
| // on le met dans un tableau d'entiers qu'on transmet au |
| // demandeur de la mise à jour |
| r.rafraichir(nbImages, true); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ImportObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,53 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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; |
| public class ImportObservationAsynchroneDAO { |
| private ObservationModele oModele = null ; |
| public ImportObservationAsynchroneDAO(ObservationModele observationModele) { |
| oModele = observationModele; |
| } |
| public void importerObservations() { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() |
| + "/InventoryImport/" + oModele.getIdentifiant()); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if(response.getText().equals("OK")) { |
| } |
| else |
| { |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/EntiteGeographiqueObservation.java |
|---|
| New file |
| 0,0 → 1,57 |
| package org.tela_botanica.client.modeles; |
| /** |
| * |
| * Classe representant une entite geographique (localite, commune, lieu dit) presente dans la liste des observations |
| * |
| */ |
| public class EntiteGeographiqueObservation { |
| private String entite=null; |
| private String idEntite=null; |
| private String idParent=null; |
| public EntiteGeographiqueObservation() { |
| } |
| /** |
| * @param commune |
| * @param departement |
| */ |
| public EntiteGeographiqueObservation(String entite, String idEntite, String idParent) { |
| this.entite = entite; |
| this.idEntite = idEntite; |
| this.idParent = idParent; |
| } |
| public String getIdLocation() { |
| return entite; |
| } |
| public String getLocation() { |
| return idEntite; |
| } |
| public String getLieuDit() { |
| return idParent; |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/Configuration.java |
|---|
| New file |
| 0,0 → 1,90 |
| package org.tela_botanica.client.modeles; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.i18n.client.Dictionary; |
| /** |
| * Classe chargeant certains paramètres de configuration à partir d'un fichier |
| * javascript (config.js) |
| * |
| * @author aurelien |
| * |
| */ |
| public class Configuration { |
| /** |
| * L'url de base du serveur jrest |
| */ |
| private static String serviceBaseUrl; |
| private static String imageBaseUrl; |
| private static String suiviBugUrl ; |
| private static String aideBaseUrl ; |
| /** |
| * Constructeur sans argument |
| */ |
| public Configuration() { |
| // on utilise le dictionnaire d'internationalisation pour lire les |
| // variables du fichier javascript |
| if(GWT.isScript()) { |
| serviceBaseUrl = Dictionary.getDictionary("configuration").get( |
| "serviceBaseUrl"); |
| suiviBugUrl = Dictionary.getDictionary("configuration").get( |
| "suiviBugUrl"); |
| imageBaseUrl = Dictionary.getDictionary("configuration").get( |
| "imageBaseUrl"); |
| aideBaseUrl = Dictionary.getDictionary("configuration").get( |
| "aideBaseUrl"); |
| } |
| else |
| { |
| serviceBaseUrl = "http://localhost/jrest"; |
| suiviBugUrl = "http://www.tela-botanica.org/suivi/index.php?do=newtask&project=2"; |
| aideBaseUrl = "http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=AideCEL"; |
| imageBaseUrl = "http://localhost/Documents/images_serveur/"; |
| } |
| } |
| /** |
| * Accesseur pour l'url de base du serveur jrest |
| * |
| * @return une url de la forme http://emplacement_serveur/jrest |
| */ |
| public static String getServiceBaseUrl() { |
| return serviceBaseUrl; |
| } |
| /** |
| * Accesseur pour l'url de base du suivi de bug |
| * |
| * @return une url pointant vers le suivi des bugs |
| */ |
| public static String getSuiviBugUrl() { |
| return suiviBugUrl; |
| } |
| /** |
| * Accesseur pour l'url de base des images |
| * |
| * @return une url pointant vers la racine du dossier contenant les images |
| */ |
| public static String getImageBaseUrl() { |
| return imageBaseUrl ; |
| } |
| /** |
| * Accesseur pour l'url de base de l'aide |
| * |
| * @return une url pointant vers la racine de l'aide |
| */ |
| public static String getAideBaseUrl() { |
| return aideBaseUrl ; |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/MotsClesAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,258 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.Window; |
| /** |
| * DAO d'accès à l'arbre de mots clés |
| * |
| * @author aurelien |
| * |
| */ |
| public class MotsClesAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ImageModele iModele = null; |
| private ObservationModele oModele = null ; |
| private String identifiant = "" ; |
| public MotsClesAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| identifiant = im.getIdentifiant(); |
| } |
| public MotsClesAsynchroneDAO(ObservationModele om) { |
| oModele = om; |
| identifiant = om.getIdentifiant(); |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param im |
| * le modèle à associer |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir l'arbre des mots clés |
| * |
| * @param r |
| * le rafraichissable qui demande les données |
| */ |
| public void obtenirListeMotsCles(final Rafraichissable r) { |
| // on demande tous les mots clés associés à l'utilisateur |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/" + identifiant); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si la requête est un succès on reçoit un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // et on met à jour le demandeur des données |
| r.rafraichir(reponse, true); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| /** |
| * Envoie requete au serveur jrest pour ajouter un mot clé |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void ajouterBaseDeDonnees(String motcle) { |
| if (!motcle.equals("")) { |
| String postData = motcle; |
| // on fait un post asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| // si on reçoit une erreur d'ajout, on affiche un |
| // message d'erreur |
| if (response.getText().equals("ERROR")) { |
| Window |
| .alert("Attention, la base de données des mots clés n'est plus synchronisée avec l'application," |
| + "nous vous invitons à recharger la page. "); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * Envoie requete au serveur jrest pour supprimer un mot clé |
| * |
| * @param motcle |
| * le mots clés à supprimer |
| */ |
| public void supprimerBaseDeDonnees(String motcle) { |
| if (!motcle.equals("")) { |
| String postData = ""; |
| postData += "&action=DELETE"; |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/" |
| + identifiant |
| + "/" |
| + motcle); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.equals("ERROR")) { |
| Window |
| .alert("Attention, la base de données des mots clés n'est plus synchronisée avec l'application," |
| + "nous vous invitons à recharger la page. "); |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * Envoie requete au serveur jrest pour modifier un mot clé |
| * |
| * @param motcle |
| * le mots clés à modifier avec son parent et son identifiant |
| */ |
| public void modifierBaseDeDonnees(String motcle) { |
| if (!motcle.equals("")) { |
| String postData = ""; |
| postData += "&action=modification" + motcle; |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/" + identifiant); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| // TODO Auto-generated method stub |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /** |
| * Envoie requete au serveur jrest pour modifier un mot clé |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son ancien parent, son nouveau et |
| * son identifiant |
| */ |
| public void deplacerBaseDeDonnees(String motcle) { |
| if (!motcle.equals("")) { |
| String postData = ""; |
| postData += "&action=deplacement" + motcle; |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, Configuration.getServiceBaseUrl() |
| + "/InventoryKeyWordList/" + identifiant); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| // TODO Auto-generated method stub |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeReferentielCommuneAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,155 |
| package org.tela_botanica.client.modeles; |
| import java.util.HashMap; |
| import org.tela_botanica.client.interfaces.FournisseurListe; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| /** |
| * DAO la liste des communes. Utilisation d'un cache pour eviter les requetes inutiles |
| * @author David Delon |
| * |
| */ |
| public class ListeReferentielCommuneAsynchroneDAO implements FournisseurListe { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ObservationModele observationModele = null; |
| /** |
| * Cache |
| * |
| */ |
| private HashMap<String,ListeReferentielCommune> cache = new HashMap(); |
| /** |
| * Constructeur. |
| * @param obs : Modele |
| */ |
| public ListeReferentielCommuneAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele = obs; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres. |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param critere un string contenant le terme a rechercher |
| */ |
| public final void obtenirListeDonnees(final Rafraichissable r, final String critere) { |
| ListeReferentielCommune referentielCommuneDataFromCache=null; |
| // En cache ? |
| if ((referentielCommuneDataFromCache=getFromCache(critere))!=null) { |
| r.rafraichir(referentielCommuneDataFromCache,true); |
| } |
| else { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, observationModele.getConfig().getServiceBaseUrl() + "/LocationSearch/" + URL.encodeComponent(critere)); |
| 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) { |
| final ListeReferentielCommune referentielCommuneData; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = null; |
| // si c'est un tableau |
| if ((reponse = responseValue.isArray()) != null) { |
| JSONArray communes; |
| final int taillemax = reponse.size(); |
| referentielCommuneData = new ListeReferentielCommune(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((communes = reponse.get(i).isArray()) != null) { |
| String commune = ((JSONString) communes.get(0)).stringValue(); |
| String departement = ((JSONString) communes.get(1)).stringValue(); |
| ReferentielCommune com = new ReferentielCommune(commune, departement); |
| referentielCommuneData.put(com.getCommune() + com.getDepartement(), com); |
| } |
| } |
| } else { |
| referentielCommuneData = new ListeReferentielCommune(0); |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| addToCache(critere, referentielCommuneData); |
| r.rafraichir(referentielCommuneData, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } // Fin else si pas de cache |
| } |
| private void addToCache(String query, ListeReferentielCommune result) { |
| cache.put(query.toLowerCase(),result); |
| } |
| private ListeReferentielCommune getFromCache (String query) { |
| return (ListeReferentielCommune) cache.get(query.toLowerCase()); |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeDateObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,94 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| 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.Window; |
| public class ListeDateObservationAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ObservationModele observationModele = null; |
| /** |
| * Constructeur. |
| * @param obs : Modele |
| */ |
| public ListeDateObservationAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele = obs; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir les communes correspondant |
| * à des critères données en paramètres. |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param critere un string contenant le terme a rechercher |
| */ |
| public final void obtenirListeDate(final Rafraichissable r, final String utilisateur) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() + "/InventoryDateList/" + utilisateur); |
| 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) { |
| final ListeDateObservation lDateObs; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = responseValue.isArray(); |
| // si c'est un tableau |
| if ((reponse) != null) { |
| lDateObs = new ListeDateObservation(reponse); |
| } else { |
| lDateObs = new ListeDateObservation(0); |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| r.rafraichir(lDateObs, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/LienImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,263 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.Util; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| 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.Window; |
| public class LienImageAsynchroneDAO { |
| private ImageModele iModele = null ; |
| private ObservationModele oModele = null ; |
| private Rafraichissable raf = null ; |
| public LienImageAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| } |
| public LienImageAsynchroneDAO(ObservationModele om) { |
| oModele = om; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param im |
| * le modèle à associer |
| */ |
| public void setIModele(ImageModele im) { |
| iModele = im; |
| } |
| public void obtenirLiaisonsImagesObservations(Rafraichissable r,String id) |
| { |
| String paramGet = "&coi_ce_image="+id ; |
| raf = r ; |
| // et on envoie ça au serveur |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/" + iModele.getIdentifiant() + "/" + paramGet); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| final ListeObservation observationData ; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse=null; |
| // si c'est un tableau |
| if ((reponse=responseValue.isArray()) != null) { |
| JSONArray observation; |
| final int taillemax = reponse.size(); |
| observationData = new ListeObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((observation=reponse.get(i).isArray()) != null) { |
| String transmis=((JSONString) observation.get(13)).stringValue(); |
| String identifiantLocalite=((JSONString) observation.get(14)).toString(); |
| String nomSaisi=Util.toCelString(((JSONString) observation.get(0)).toString()); |
| String nomRetenu=Util.toCelString(((JSONString) observation.get(2)).toString()); |
| String numeroNomenclaturalSaisi=((JSONString) observation.get(1)).stringValue(); |
| String numeroNomenclaturalRetenu=((JSONString) observation.get(3)).stringValue(); |
| String numeroTaxonomique=((JSONString) observation.get(4)).stringValue(); |
| String famille=Util.toCelString(((JSONString) observation .get(5)).toString()); |
| String localite=Util.toCelString(((JSONString) observation .get(6)).toString()); |
| String lieudit=Util.toCelString(((JSONString) observation .get(9)).toString()); |
| String station=Util.toCelString(((JSONString) observation .get(10)).toString()); |
| String milieu=Util.toCelString(((JSONString) observation .get(11)).toString()); |
| String commentaire=Util.toCelString(((JSONString) observation .get(12)).toString()); |
| String date=((JSONString) observation .get(8)).stringValue(); |
| String numeroOrdre=((JSONString) observation.get(7)).stringValue(); |
| Observation obs=new Observation(transmis, nomSaisi, nomRetenu, numeroNomenclaturalSaisi, numeroNomenclaturalRetenu ,numeroTaxonomique, famille, localite, identifiantLocalite, lieudit, station, milieu, commentaire, date, numeroOrdre); |
| observationData.put(obs.getNumeroOrdre(),obs); |
| } |
| } |
| } else { |
| observationData = new ListeObservation(0) ; |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| // TODO : ce n'est pas ici qu'on devrait le decider .. |
| raf.rafraichir(observationData,true); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void obtenirLiaisonsObservationsImages(Rafraichissable r,String idObs, String utilisateur) |
| { |
| String paramGet = "&coi_ce_observation="+idObs ; |
| raf = r ; |
| // et on envoie ça au serveur |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/" + utilisateur + "/" + paramGet); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| String baseUrl = Configuration.getImageBaseUrl() ; |
| final JSONValue responseValue = JSONParser.parse(response |
| .getText()); |
| // si c'est un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| final int taillemax = reponse.size(); |
| String imgTab[][] = new String[taillemax][3] ; |
| for(int i = 0 ;i<taillemax ;i++) |
| { |
| final JSONArray reponseInt = reponse.get(i).isArray(); |
| String idImg = ((JSONString)reponseInt.get(0)).stringValue() ; |
| String X = ((JSONString)reponseInt.get(1)).stringValue() ; |
| String Y = ((JSONString)reponseInt.get(2)).stringValue() ; |
| imgTab[i][0] = idImg ; |
| imgTab[i][1] = X ; |
| imgTab[i][2] = Y ; |
| } |
| raf.rafraichir(imgTab, false) ; |
| } |
| else |
| { |
| String imgTab[] = new String[0] ; |
| raf.rafraichir(imgTab, false) ; |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void lierImageBaseDeDonnees(String idsImages, String idsObs) { |
| String postData = ""; |
| postData += "&coi_ce_image="+idsImages ; |
| postData += "&coi_ce_observation="+idsObs ; |
| postData += "&identifiant="+iModele.getIdentifiant() ; |
| // et on envoie ça au serveur |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/"); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| // quand la requête est éxecutée on le signale au modèle |
| // pour qu'il mette à jour les données |
| // et en notifie le médiateur |
| //iModele.requeteTerminee(); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void supprimerLienImageObservation(String idImg, String idObs) { |
| String postData = ""; |
| postData += "&action=DELETE" ; |
| String identifiant = "" ; |
| if(iModele == null) { |
| identifiant = oModele.getIdentifiant() ; ; |
| } |
| else |
| { |
| identifiant = iModele.getIdentifiant() ; |
| } |
| // et on envoie ça au serveur |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/"+identifiant+"/"+idImg+"/"+idObs); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| // quand la requête est éxecutée on le signale au modèle |
| // poru qu'il mette à jour les données |
| // et en notifie le médiateur |
| // iModele.requeteTerminee(); |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,181 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.Window; |
| /** |
| * DAO d'accès a une observation |
| * |
| * @author aurelien |
| * |
| */ |
| public class ObservationAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele oModele = null; |
| public ObservationAsynchroneDAO(ObservationModele obs) { |
| oModele = obs; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param obs |
| * le modèle à associer |
| */ |
| public void setoModele(ObservationModele obs) { |
| oModele = obs; |
| } |
| /** |
| * Envoie requete au serveur pour ajouter une observations |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void ajouter(final Rafraichissable r, String utilisateur, final Observation obs) { |
| // private void addElement(String nom_sel, String num_nom_sel, String nom_ret, |
| // String num_nom_ret, String num_taxon, String famille,final String loc, String id_location,String dat, String lieu, String sta, String mil, String comment) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl()+ "/Inventory/") ; |
| String postData = "identifiant=" |
| + utilisateur + "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi()) + "&num_nom_sel=" + obs.getNumeroNomenclaturalSaisi() |
| + "&location=" + URL.encodeComponent(obs.getLocalite()) + "&id_location=" + obs.getIdentifiantLocalite() + "&date_observation=" + obs.getDate() |
| + "&lieudit="+ URL.encodeComponent(obs.getLieudit()) + "&station="+ URL.encodeComponent(obs.getStation()) +"&milieu="+ URL.encodeComponent(obs.getMilieu()) + "&commentaire="+ URL.encodeComponent(""+obs.getCommentaire()) ; |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| r.rafraichir(obs,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| /** |
| * Envoie requete au serveur pour modifier une observations |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void modifier(final Rafraichissable r, String utilisateur, final Observation obs) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl()+ "/Inventory/" + utilisateur + "/" + obs.getNumeroOrdre()+ "/") ; |
| String postData = "identifiant=" |
| + utilisateur |
| + "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi()) |
| + "&num_nom_sel=" + obs.getNumeroNomenclaturalSaisi() |
| + "&location=" + URL.encodeComponent(obs.getLocalite()) |
| + "&id_location=" + obs.getIdentifiantLocalite() |
| + "&date_observation=" + obs.getDate() |
| + "&lieudit="+ URL.encodeComponent(obs.getLieudit()) |
| + "&station="+ URL.encodeComponent(obs.getStation()) |
| +"&milieu="+ URL.encodeComponent(obs.getMilieu()) |
| +"&commentaire="+URL.encodeComponent(""+obs.getCommentaire())/*+"&mots_cles="+URL.encodeComponent(obs.getMotsCles()) */; |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| r.rafraichir(obs,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void supprimer(Rafraichissable r, String identifiant, String numeroOrdre) { |
| String postData = ""; |
| postData += "&action=DELETE"; |
| // on envoie un post avec l'id de l'image à supprimer |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventory/" |
| + identifiant |
| + "/" |
| + numeroOrdre); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| return ; |
| } |
| } |
| }); |
| r.rafraichir("OK", true) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/Utilisateur.java |
|---|
| New file |
| 0,0 → 1,72 |
| package org.tela_botanica.client.modeles; |
| public class Utilisateur { |
| private String identifiant=null; |
| private String identite=null; |
| private boolean identifie=false; |
| private boolean isAdmin=false; |
| public Utilisateur(String identifiant, boolean identifie) { |
| this.identifiant=identifiant; |
| this.identifie=identifie; |
| this.identite=identifiant; |
| } |
| public Utilisateur(String identifiant, boolean identifie, boolean isAdmin) { |
| this.identifiant=identifiant; |
| this.identifie=identifie; |
| this.isAdmin=isAdmin; |
| this.identite=identifiant; |
| } |
| /** |
| * Retourne l'identifiant de l'utilisateur identifie ou un identifiant de session |
| * @return String identifiant |
| */ |
| public String getIdentifiant() { |
| return identifiant; |
| } |
| /** |
| * Retourne vrai si utilisateur identifie |
| * @return boolean |
| */ |
| public boolean isIdentifie() { |
| return identifie; |
| } |
| /** |
| * Retourne vrai si utilisateur est admin |
| * @return boolean |
| */ |
| public boolean isAdmin() { |
| return isAdmin; |
| } |
| /** |
| * Met à jour l'identité utilisée (dans le cas où l'utilisateur est admin) |
| * @param identite la nouvelle identité |
| */ |
| public void setIdentite(String identite) { |
| if(isAdmin()) { |
| this.identite = identite; |
| } |
| else { |
| this.identite = identifiant ; |
| } |
| } |
| /** |
| * Renvoie l'identité en cours d'utilisation (par défaut, la même valeur que l'identifiant si |
| * l'utilisateur est admin) |
| * @return identite |
| */ |
| public String getIdentite() { |
| return identite; |
| } |
| } |
| /branches/v1.0-becassine/src/org/tela_botanica/client/modeles/ListeObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,261 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.Util; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationModele; |
| 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.json.client.JSONArray; |
| 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.Window; |
| /** |
| * DAO la liste des observations attachées a un observateur. |
| * @author David Delon |
| * TODO : se servir de ObservationDAO pour la lecture unitaire |
| * |
| */ |
| public class ListeObservationAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ObservationModele observationModele = null; |
| public ListeObservationAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele=obs; |
| } |
| /** |
| * Envoie une requete au serveur jrest pour obtenir le nombre d'observation correspondant |
| * à des critères données en paramètres |
| * @param r le rafraichissable qui demande la mise à jour |
| * @param criteres un tableau nom/valeur des critères pour les observations |
| */ |
| public final void obtenirListeObservation(final Rafraichissable r, final String utilisateur, final String[][] criteres) |
| { |
| String requete = "" ; |
| if(criteres != null) |
| { |
| // on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...) |
| // ils contiennent limite et taille page et autres filtres (communes , lieu dit etc ...)S |
| for (int i = 0; i < criteres.length; i++) { |
| if(!criteres[i][1].equals("")) |
| { |
| if(i!= 0) |
| { |
| requete += "&"; |
| } |
| requete += criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ; |
| } |
| } |
| } |
| // on envoie le get asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,Configuration.getServiceBaseUrl() |
| +"/InventoryObservationList/"+utilisateur+"/"+requete) ; |
| 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) { |
| final ListeObservation observationData ; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse=null; |
| // si c'est un tableau |
| if ((reponse=responseValue.isArray()) != null) { |
| JSONArray observation; |
| final int taillemax = reponse.size(); |
| observationData = new ListeObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((observation=reponse.get(i).isArray()) != null) { |
| String transmis=((JSONString) observation.get(13)).stringValue(); |
| String identifiantLocalite=((JSONString) observation.get(14)).toString(); |
| String nomSaisi=Util.toCelString(((JSONString) observation.get(0)).toString()); |
| String nomRetenu=Util.toCelString(((JSONString) observation.get(2)).toString()); |
| String numeroNomenclaturalSaisi=((JSONString) observation.get(1)).stringValue(); |
| String numeroNomenclaturalRetenu=((JSONString) observation.get(3)).stringValue(); |
| String numeroTaxonomique=((JSONString) observation.get(4)).stringValue(); |
| String famille=Util.toCelString(((JSONString) observation .get(5)).toString()); |
| String localite=Util.toCelString(((JSONString) observation .get(6)).toString()); |
| String lieudit=Util.toCelString(((JSONString) observation .get(9)).toString()); |
| String station=Util.toCelString(((JSONString) observation .get(10)).toString()); |
| String milieu=Util.toCelString(((JSONString) observation .get(11)).toString()); |
| String commentaire=Util.toCelString(((JSONString) observation .get(12)).toString()); |
| String date=((JSONString) observation .get(8)).stringValue(); |
| String numeroOrdre=((JSONString) observation.get(7)).stringValue(); |
| //String motsCles=((JSONString) observation.get(15)).stringValue(); |
| Observation obs=new Observation(transmis, nomSaisi, nomRetenu, numeroNomenclaturalSaisi, numeroNomenclaturalRetenu ,numeroTaxonomique, famille, localite, identifiantLocalite, lieudit, station, milieu, commentaire, date, numeroOrdre/*, motsCles*/); |
| observationData.put(obs.getNumeroOrdre(),obs); |
| } |
| } |
| } else { |
| observationData = new ListeObservation(0) ; |
| } |
| // dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
| // le premier à les recevoir |
| // TODO : ce n'est pas ici qu'on devrait le decider .. |
| r.rafraichir(observationData,true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| public void modifierEnMasse(final Rafraichissable r, String identifiant, |
| final Observation obs) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl()+ "/InventoryObservationList/" + identifiant + "/" + obs.getNumeroOrdre()+ "/") ; |
| String postData = "identifiant=" |
| + identifiant ; |
| if(obs.getNomSaisi() != null) { |
| postData += "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi()); |
| } |
| if(obs.getNumeroNomenclaturalSaisi() != null) { |
| postData += "&num_nom_sel=" + obs.getNumeroNomenclaturalSaisi(); |
| } |
| if(obs.getIdentifiantLocalite() != null) { |
| postData += "&id_location=" + obs.getIdentifiantLocalite(); |
| } |
| if(obs.getLocalite() != null) { |
| postData += "&location=" + URL.encodeComponent(obs.getLocalite()); |
| } |
| if(obs.getDate() != null) { |
| postData += "&date_observation=" + obs.getDate(); |
| } |
| if(obs.getLieudit() != null) { |
| postData += "&lieudit="+ URL.encodeComponent(obs.getLieudit()); |
| } |
| if(obs.getStation() != null) { |
| postData += "&station="+ URL.encodeComponent(obs.getStation()); |
| } |
| if(obs.getMilieu() != null) { |
| postData += "&milieu="+ URL.encodeComponent(obs.getMilieu()); |
| } |
| if(obs.getCommentaire() != null) { |
| postData += "&commentaire="+URL.encodeComponent(""+obs.getCommentaire()); |
| } |
| /*+"&mots_cles="+URL.encodeComponent(obs.getMotsCles()) */; |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| observationModele.obtenirListeObservation(r); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| /** |
| * Supprime les observations possédant les identifiants données |
| * @param r le rafraichissable à avertir de la mise à jour |
| * @param identifiant l'identifiant utilisateur |
| * @param numerosOrdre les numéros d'ordre des observations séparés par des virgules |
| */ |
| public void supprimerListeObservation(Rafraichissable r, String identifiant, String numerosOrdre) { |
| String postData = ""; |
| postData += "&action=DELETE"; |
| // on envoie un post avec l'id de l'image à supprimer |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventoryObservationList/" |
| + identifiant |
| + "/" |
| + numerosOrdre); |
| try { |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getText().equals("OK")) { |
| } else { |
| com.google.gwt.user.client.Window |
| .alert("Problème lors de la mise à jour des données"); |
| return ; |
| } |
| } |
| }); |
| r.rafraichir("OK", true) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |