| /trunk/src/org/tela_botanica/client/modeles/dao/LiaisonMotsClesObsAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,103 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| 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; |
| /** |
| * DAO d'accès à la liaison entre mots clés et observations |
| * |
| * @author aurelien |
| * |
| */ |
| public class LiaisonMotsClesObsAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ObservationModele oModele = null; |
| public LiaisonMotsClesObsAsynchroneDAO(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 modifier une observations |
| * |
| * @param motcle |
| * le mots clés à ajouter avec son parent et son identifiant |
| */ |
| public void modifier(final Rafraichissable r, String utilisateur, String idObs, String idMC) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordObsLink/") ; |
| String postData = "ce_utilisateur="+utilisateur |
| +"&observations="+idObs |
| +"&mots_cles="+URL.encodeComponent(""+idMC); |
| 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) { |
| oModele.obtenirListeObservation(r); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void supprimer(final Rafraichissable r, String utilisateur, String idObs, String idMC) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordObsLink/" + utilisateur + "/" +idObs+ "/" + URL.encodeComponent(""+idMC) + "/") ; |
| String postData = "&action=DELETE"; |
| 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) { |
| oModele.obtenirListeObservation(r); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/NomRetenuAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,69 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import org.tela_botanica.client.util.Util; |
| 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 = ((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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeReferentielPersoAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,101 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.HashMap; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| 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; |
| public class ListeReferentielPersoAsynchroneDAO { |
| /** |
| * Cache |
| * |
| */ |
| private HashMap<String,ListeReferentielPerso> cache = new HashMap(); |
| private TypesReferentiels refDemande = null; |
| public ListeReferentielPersoAsynchroneDAO(ObservationModele obs) { |
| } |
| public void setRefDemande(TypesReferentiels refDemande) { |
| this.refDemande = refDemande; |
| } |
| public void obtenirListeDonnees(final Rafraichissable r, String utilisateur, final String critere) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() + |
| "/SelfRefList/"+ |
| utilisateur+"/"+ |
| refDemande.toString()+ |
| "?start=0&limit=50&recherche="+URL.encode(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 ListeReferentielPerso referentielData; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = null; |
| // si c'est un tableau |
| if ((reponse = responseValue.isArray()) != null) { |
| JSONString elementsRef; |
| final int taillemax = reponse.size(); |
| referentielData = new ListeReferentielPerso(taillemax, refDemande); |
| for (int i = 0; i < taillemax; i++) { |
| if ((elementsRef = reponse.get(i).isString()) != null) { |
| String valeur = elementsRef.stringValue(); |
| referentielData.put(i+"", valeur); |
| } |
| } |
| } else { |
| referentielData = new ListeReferentielPerso(0, refDemande); |
| } |
| // 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(referentielData, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ImageUploaderAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,164 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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("ce_utilisateur",Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| UrlParam[] params = { id }; |
| up.setBaseParams(params); |
| up.setModal(true); |
| up.addListener(new UploadDialogListenerAdapter() { |
| public void onClose(Panel panel) { |
| iModele.setDernierePage(); |
| iModele.requeteTerminee(); |
| } |
| public void onUploadComplete(UploadDialog source) { |
| iModele.setDernierePage(); |
| 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=\"ce_utilisateur\" value=\"" |
| + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "\">" + "</form>"; |
| nPan.setHtml(warning + appelApplet + htmlForm); |
| nPan.setModal(true); |
| nPan.addListener(new WindowListenerAdapter() { |
| public void onClose(Panel panel) { |
| iModele.setDernierePage(); |
| 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.dao.ImageUploaderAsynchroneDAO::appelerUploadMultiple()() ; |
| } |
| else |
| { |
| @org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO::appelerUploadSimple()() ; |
| } |
| }-*/; |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeReferentielNomAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,175 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.HashMap; |
| import org.tela_botanica.client.interfaces.FournisseurListe; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielNom; |
| import org.tela_botanica.client.modeles.objets.ReferentielNom; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import org.tela_botanica.client.util.Util; |
| 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 = ((JSONString) noms.get(0)).toString(); |
| String numeroNom = ((JSONString) noms.get(1)).toString(); |
| String statut= ((JSONString) noms.get(2)).toString(); |
| ReferentielNom nomScientifique=new ReferentielNom(nom, numeroNom, statut); |
| // 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()); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/InformationCommuneDAO.java |
|---|
| New file |
| 0,0 → 1,182 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import com.google.gwt.core.client.GWT; |
| 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.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.maps.client.geom.LatLng; |
| import com.google.gwt.user.client.Window; |
| public class InformationCommuneDAO { |
| private final String NOM_SERVICE = "CoordSearch"; |
| private final String CODE_PAYS = "FR"; |
| Rafraichissable r = null; |
| public InformationCommuneDAO(Rafraichissable r) { |
| this.r = r; |
| } |
| public void obtenirCommunePlusProche(final Rafraichissable r, final double lng, |
| final double lat) { |
| String adresseAppel = Configuration.getServiceBaseUrl() + "/" |
| + NOM_SERVICE + "/" + URL.encode("" + lat) + "/" |
| + URL.encode("" + lng) + "/*/*/"; |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, adresseAppel); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| Window.alert(exception.getMessage()); |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| EntiteGeographiqueObservation infos; |
| String idLocalite = ""; |
| String nomCommune = ""; |
| if (response.getStatusCode() == Response.SC_BAD_REQUEST) { |
| Window.alert("Requete mal formée"); |
| } else { |
| if(response.getText().equals("")) { |
| infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null); |
| infos.setLat(""+lat); |
| infos.setLon(""+lng); |
| r.rafraichir(infos, false); |
| } |
| final JSONValue responseValue = JSONParser |
| .parse(response.getText()); |
| if (responseValue.isObject() != null) { |
| JSONObject objectRetour = responseValue.isObject(); |
| if(objectRetour.get("nom").isString() != null) { |
| nomCommune = objectRetour.get("nom").isString().stringValue(); |
| } |
| if(objectRetour.get("code_insee").isString() != null) { |
| idLocalite = objectRetour.get("code_insee").isString().stringValue().substring(0, 2); |
| } |
| } |
| } |
| infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null); |
| infos.setLat(""+lat); |
| infos.setLon(""+lng); |
| r.rafraichir(infos, false); |
| } |
| }); |
| } catch (RequestException e) { |
| Window.alert(e.getMessage()); |
| } |
| } |
| public void obtenirInfosCommune(final Rafraichissable r, |
| String valeurCommune, String codePostal) { |
| codePostal = codePostal.replaceAll("000null", "*"); |
| codePostal = codePostal.replaceAll("\"", ""); |
| valeurCommune = valeurCommune.split(" \\([0-9][0-9]\\)")[0]; |
| valeurCommune = valeurCommune.replaceAll("000null", "*"); |
| valeurCommune = valeurCommune.replaceAll("\"", ""); |
| String adresseAppel = Configuration.getServiceBaseUrl() + "/" |
| + NOM_SERVICE + "/*/*/" + URL.encode(valeurCommune) + "/" |
| + URL.encode(codePostal) + "/" |
| + URL.encode(CODE_PAYS); |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, adresseAppel); |
| try { |
| rb.sendRequest(null, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| Window.alert(exception.getMessage()); |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if (response.getStatusCode() == Response.SC_BAD_REQUEST) { |
| r.rafraichir("Impossible de géolocaliser cette observation", false); |
| } else { |
| if(response.getText().equals("")) { |
| EntiteGeographiqueObservation infos; |
| String idLocalite = ""; |
| String nomCommune = ""; |
| infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null); |
| infos.setLat(""); |
| infos.setLon(""); |
| r.rafraichir(infos, false); |
| } |
| final JSONValue responseValue = JSONParser |
| .parse(response.getText()); |
| if (responseValue.isObject() != null) { |
| EntiteGeographiqueObservation infos; |
| String idLocalite = ""; |
| String nomCommune = ""; |
| Double lng = 0.0; |
| Double lat = 0.0; |
| JSONObject objectRetour = responseValue.isObject(); |
| if(objectRetour.get("nom").isString() != null) { |
| nomCommune = objectRetour.get("nom").isString().stringValue(); |
| } |
| if(objectRetour.get("code_insee").isString() != null) { |
| idLocalite = objectRetour.get("code_insee").isString().stringValue().substring(0, 2); |
| } |
| if(objectRetour.get("lat").isNumber() != null) { |
| lat = objectRetour.get("lat").isNumber().doubleValue(); |
| } |
| if(objectRetour.get("lng").isNumber() != null) { |
| lng = objectRetour.get("lng").isNumber().doubleValue(); |
| } |
| infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null); |
| infos.setLat(""+lat); |
| infos.setLon(""+lng); |
| r.rafraichir(infos, false); |
| } |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| Window.alert(e.getMessage()); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeDateImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,99 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.core.client.GWT; |
| 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 ListeDateImageAsynchroneDAO { |
| /** |
| * Le modèle associé au DAO. |
| */ |
| private ImageModele imageModele = null; |
| /** |
| * Constructeur. |
| * @param obs : Modele |
| */ |
| public ListeDateImageAsynchroneDAO(final ImageModele obs) { |
| this.imageModele = 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() + "/ImageDateList/" + 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 ListeDate lDateObs; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = responseValue.isArray(); |
| // si c'est un tableau |
| if ((reponse) != null) { |
| lDateObs = new ListeDate(reponse); |
| } else { |
| lDateObs = new ListeDate(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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,177 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ImageCarnet; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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.user.client.Window; |
| /** |
| * 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, 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(); |
| } |
| } |
| /** |
| * 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 += "&id_image=" + id + "&id_mot_cle_utilisateur=" + motsCles; |
| // on envoie une requête asynchrone |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, |
| Configuration.getServiceBaseUrl() |
| + "/inventoryKeyWordImageList/" +Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()+ "/"); |
| 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, Configuration.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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,252 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ImageCarnet; |
| import org.tela_botanica.client.modeles.objets.ListeImageCarnet; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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, Configuration.getServiceBaseUrl() |
| + "/InventoryImageList/" |
| + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() |
| + "/" |
| + 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/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/"); |
| 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/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/" + 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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/NombreImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,114 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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/" |
| + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() |
| + "/" |
| + 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 une chaine JSON |
| if (responseValue.isString() != null) { |
| // qui contient une valeur : le nombre d'images |
| // correspondant au critères |
| JSONString reponseNombre = responseValue.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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ExportObservationsDAO.java |
|---|
| New file |
| 0,0 → 1,44 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| 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] != null && criteres[i][1] != null && !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) ; |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ImportObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,55 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| 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")) { |
| oModele.obtenirNombreObservation(null); |
| } |
| else |
| { |
| } |
| } |
| }); |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/MotsClesAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,269 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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 = "" ; |
| private String mode = ""; |
| public MotsClesAsynchroneDAO(ImageModele im) { |
| iModele = im; |
| mode = "images"; |
| identifiant = im.getIdentifiant(); |
| } |
| public MotsClesAsynchroneDAO(ObservationModele om) { |
| oModele = om; |
| mode = "obs"; |
| identifiant = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(); |
| } |
| /** |
| * 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/"+mode+"/"+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); |
| } else { |
| JSONArray vide = new JSONArray(); |
| r.rafraichir(vide, 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+"&mode="+mode; |
| // 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/" |
| + mode+"/" |
| + 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/"+mode+"/"+ 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/"+mode+"/"+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(); |
| } |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeReferentielCommuneAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,158 |
| package org.tela_botanica.client.modeles.dao; |
| import java.util.HashMap; |
| import org.tela_botanica.client.interfaces.FournisseurListe; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielCommune; |
| import org.tela_botanica.client.modeles.objets.ReferentielCommune; |
| 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, Configuration.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()); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/LienImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,243 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.core.client.GWT; |
| 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.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 = "id_image="+id ; |
| raf = r ; |
| // et on envoie ça au serveur |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, Configuration.getServiceBaseUrl() |
| + "/inventoryImageLink/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/" + 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) { |
| JSONObject observation; |
| final int taillemax = reponse.size(); |
| observationData = new ListeObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((observation = reponse.get(i).isObject()) != null) { |
| Observation obs= new Observation(observation); |
| 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 = "id_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 JSONObject reponseInt = reponse.get(i).isObject(); |
| String idImg = ((JSONString)reponseInt.get("id_image")).stringValue() ; |
| String X = ((JSONString)reponseInt.get("hauteur")).stringValue() ; |
| String Y = ((JSONString)reponseInt.get("largeur")).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 += "id_image="+idsImages ; |
| postData += "&id_observation="+idsObs ; |
| postData += "&ce_utilisateur="+Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() ; |
| // 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) { |
| 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 = "" ; |
| identifiant = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(); |
| // 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 |
| // 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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeDateObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,96 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| 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 ListeDate lDateObs; |
| final JSONValue responseValue = JSONParser.parse(response.getText()); |
| JSONArray reponse = responseValue.isArray(); |
| // si c'est un tableau |
| if ((reponse) != null) { |
| lDateObs = new ListeDate(reponse); |
| } else { |
| lDateObs = new ListeDate(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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,190 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| 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) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl()+ "/Inventory/") ; |
| String postData = "ce_utilisateur=" |
| + utilisateur |
| +"&nom_sel="+URL.encodeComponent(obs.getNomSaisi()) |
| +"&nom_sel_nn="+obs.getNumeroNomenclaturalSaisi() |
| +"&zone_geo="+URL.encodeComponent(obs.getLocalite()) |
| +"&ce_zone_geo="+obs.getIdentifiantLocalite() |
| +"&date_observation=" + obs.getDate() |
| +"&lieudit="+ URL.encodeComponent(obs.getLieudit()) |
| +"&station="+URL.encodeComponent(obs.getStation()) |
| +"&milieu="+URL.encodeComponent(obs.getMilieu()) |
| +"&commentaire="+obs.getCommentaire() |
| +"&latitude="+URL.encodeComponent(""+obs.getLatitude()) |
| +"&longitude="+URL.encodeComponent(""+obs.getLongitude());; |
| 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 = "ce_utilisateur=" |
| + utilisateur |
| + "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi()) |
| + "&nom_sel_nn=" + obs.getNumeroNomenclaturalSaisi() |
| + "&zone_geo=" + URL.encodeComponent(obs.getLocalite()) |
| + "&ce_zone_geo=" + obs.getIdentifiantLocalite() |
| + "&date_observation=" + obs.getDate() |
| + "&lieudit="+ URL.encodeComponent(obs.getLieudit()) |
| + "&station="+ URL.encodeComponent(obs.getStation()) |
| +"&milieu="+ URL.encodeComponent(obs.getMilieu()) |
| +"&commentaire="+obs.getCommentaire() |
| +"&mots_cles="+URL.encodeComponent(""+obs.getMotsCles()) |
| +"&latitude="+URL.encodeComponent(""+obs.getLatitude()) |
| +"&longitude="+URL.encodeComponent(""+obs.getLongitude()); |
| 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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,263 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.core.client.GWT; |
| 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.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.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; |
| private ImageModele imageModele = null; |
| public ListeObservationAsynchroneDAO(final ObservationModele obs) { |
| this.observationModele=obs; |
| } |
| /** |
| * Le modèle associé au DAO. |
| */ |
| public ListeObservationAsynchroneDAO(final ImageModele img) { |
| this.imageModele = img; |
| } |
| /** |
| * 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] != null && !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) { |
| JSONObject observation; |
| final int taillemax = reponse.size(); |
| observationData = new ListeObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((observation=reponse.get(i).isObject()) != null) { |
| Observation obs = new Observation(observation); |
| 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 = "ce_utilisateur=" |
| + identifiant ; |
| if(obs.getNomSaisi() != null) { |
| postData += "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi()); |
| } |
| if(obs.getNumeroNomenclaturalSaisi() != null) { |
| postData += "&nom_sel_nn=" + obs.getNumeroNomenclaturalSaisi(); |
| } |
| if(obs.getIdentifiantLocalite() != null) { |
| postData += "&ce_zone_geo=" + obs.getIdentifiantLocalite(); |
| } |
| if(obs.getLocalite() != null) { |
| postData += "&zone_geo=" + 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="+obs.getCommentaire(); |
| } |
| if(obs.getLatitude() != null ) { |
| postData += "&latitude="+URL.encodeComponent(""+obs.getLatitude()); |
| } |
| if(obs.getLongitude() != null) { |
| postData += "&longitude="+URL.encodeComponent(""+obs.getLongitude()); |
| } |
| 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(observationModele != null) { |
| 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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/NombreObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,113 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import com.google.gwt.core.client.GWT; |
| 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.ResponseTextHandler; |
| import com.google.gwt.user.client.Window; |
| /** |
| * 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 ; |
| private ImageModele imageModele = null; |
| public NombreObservationAsynchroneDAO(ObservationModele observationModele) |
| { |
| this.observationModele=observationModele; |
| } |
| public NombreObservationAsynchroneDAO(final ImageModele imageModele) { |
| this.imageModele = imageModele; |
| } |
| /** |
| * 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] != null && !criteres[i][1].equals("")) |
| { |
| 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.isString() != null) |
| { |
| // qui contient une valeur : le nombre d'images correspondant au critères |
| JSONString res = responseValue.isString() ; |
| int maxObservations = Integer.parseInt(res.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) { |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/TransmissionObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,68 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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/"+Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()+"/"+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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeEntiteGeographiqueObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,124 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.FournisseurListe; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation; |
| import org.tela_botanica.client.observation.ObservationModele; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.core.client.GWT; |
| 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.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) { |
| JSONObject entites; |
| final int taillemax = reponse.size(); |
| listeEntiteGeographiqueObservation = new ListeEntiteGeographiqueObservation(taillemax); |
| for (int i = 0; i < taillemax; i++) { |
| if ((entites = reponse.get(i).isObject()) != null) { |
| String idZoneGeo = Util.convertirChaineZoneGeoVersDepartement(((JSONString) entites.get("ce_zone_geo")).stringValue()); |
| String zoneGeo = ((JSONString) entites.get("zone_geo")).stringValue(); |
| String lieuDit = ((JSONString) entites.get("lieudit")).stringValue(); |
| String station = ((JSONString) entites.get("station")).stringValue(); |
| EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(idZoneGeo, zoneGeo, lieuDit, station); |
| 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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ImageGeneriqueVueAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,89 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| 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 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,Configuration.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; |
| String urlImageMax=null; |
| if ((reponse = responseValue.isArray()) != null) { |
| // Url Image |
| urlImage= ((JSONString)reponse.get(0)).stringValue(); |
| urlImageMax= ((JSONString)reponse.get(1)).stringValue(); |
| } |
| else { |
| urlImage=""; |
| urlImageMax=""; |
| } |
| r.rafraichir(new String[]{urlImage,urlImageMax},true); |
| } |
| }) ; |
| } catch (RequestException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ImageInformationRepartitionAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,86 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| 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,Configuration.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(); |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/UtilisateurAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,178 |
| package org.tela_botanica.client.modeles.dao; |
| /** |
| * 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 org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| 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.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.Window; |
| 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) { |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| if(response.getText().isEmpty()) { |
| Window.alert("Impossible de contacter le serveur, veuillez vérifier la configuration du cel ou contacter un administrateur"); |
| } else { |
| JSONValue jsonValue = JSONParser.parse(response.getText()); |
| JSONObject objetJsonUtilisateur; |
| if ((objetJsonUtilisateur = jsonValue.isObject()) != null) { |
| Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur); |
| r.rafraichir(utilisateur,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()); |
| JSONObject objetJsonUtilisateur; |
| if ((objetJsonUtilisateur = jsonValue.isObject()) != null) { |
| Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur); |
| r.rafraichir(utilisateur,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()); |
| JSONObject objetJsonUtilisateur; |
| if ((objetJsonUtilisateur = jsonValue.isObject()) != null) { |
| Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur); |
| r.rafraichir(utilisateur,true); |
| } |
| } |
| }) ; |
| } catch (RequestException e) { |
| e.printStackTrace() ; |
| } |
| } |
| public void accepterLicence(String identifiantUtilisateur) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl() + "/LicenceUtilisateur/"+identifiantUtilisateur) ; |
| try { |
| String postData = "licence=1"; |
| rb.sendRequest(postData, new RequestCallback() { |
| public void onError(Request request, Throwable exception) { |
| // TODO Auto-generated method stub |
| } |
| public void onResponseReceived(Request request, |
| Response response) { |
| } |
| }) ; |
| } catch (RequestException e) { |
| e.printStackTrace() ; |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/LiaisonMotsClesImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,105 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.image.ImageModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| 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 à la liaison entre mots clés et observations |
| * |
| * @author aurelien |
| * |
| */ |
| public class LiaisonMotsClesImageAsynchroneDAO { |
| /** |
| * Le modele associé au DAO |
| */ |
| private ImageModele iModele = null; |
| public LiaisonMotsClesImageAsynchroneDAO(ImageModele img) { |
| iModele = img; |
| } |
| /** |
| * Setteur pour le modèle |
| * |
| * @param img |
| * le modèle à associer |
| */ |
| public void setiModele(ImageModele img) { |
| iModele = img; |
| } |
| /** |
| * 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, String idImg, String idMC) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordImageLink/") ; |
| String postData = "ce_utilisateur="+utilisateur |
| +"&images="+idImg |
| +"&mots_cles="+URL.encodeComponent(""+idMC); |
| 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) { |
| Window.alert("Liaison aux mots clés effectuée"); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| public void supprimer(final Rafraichissable r, String utilisateur, String idImg, String idMC) { |
| RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordImageLink/" + utilisateur + "/" +idImg+ "/" + URL.encodeComponent(""+idMC) + "/") ; |
| String postData = "&action=DELETE"; |
| 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) { |
| Window.alert("Liaison aux mots clés supprimée"); |
| } |
| }) ; |
| } catch (RequestException e) { |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/dao/ListeUtilisateurAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,76 |
| package org.tela_botanica.client.modeles.dao; |
| import org.tela_botanica.client.CarnetEnLigneModele; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| 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.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()][2]; |
| for(int i = 0; i < reponse.size() ; i++) { |
| JSONObject item = reponse.get(i).isObject(); |
| if(item != null) { |
| util[i][0] = item.get("id_utilisateur").isString().stringValue(); |
| util[i][1] = item.get("courriel").isString().stringValue(); |
| } |
| } |
| } |
| else { |
| util = new String[0][2]; |
| } |
| r.rafraichir(util, true); |
| } |
| }); |
| } catch (RequestException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |