Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 1 → Rev 2

/trunk/src/org/tela_botanica/client/modeles/Observation.java
New file
0,0 → 1,95
package org.tela_botanica.client.modeles;
 
 
public class Observation {
 
 
private int nombreObservations=0;
private Observation [] listeObservation=null;
 
private String transmis=null;
private String nomSaisi=null;
private String nomRetenu=null;
private String numeroNomenclatural=null;
private String numeroTaxonomique=null;
private String famille=null;
private String localite=null;
private String lieudit=null;
private String station=null;
private String milieu=null;
private String commentaire=null;
private String date=null;
private String numeroOrdre=null;
 
 
public Observation() {
}
 
/**
* Constructeur nombre total d'observations
* @param i
*/
public Observation(int i) {
nombreObservations=i;
}
 
public int getNombreObservations() {
return nombreObservations;
}
 
 
/**
* @param transmis
* @param nomSaisi
* @param nomRetenu
* @param numeroNomenclatural
* @param numeroTaxonomique
* @param famille
* @param localite
* @param lieudit
* @param station
* @param milieu
* @param commentaire
* @param date
* @param numeroOrdre
*/
public Observation(String transmis, String nomSaisi, String nomRetenu, String numeroNomenclatural, String numeroTaxonomique, String famille, String localite, String lieudit, String station, String milieu, String commentaire, String date, String numeroOrdre) {
this.transmis = transmis;
this.nomSaisi = nomSaisi;
this.nomRetenu = nomRetenu;
this.numeroNomenclatural = numeroNomenclatural;
this.numeroTaxonomique = numeroTaxonomique;
this.famille = famille;
this.localite = localite;
this.lieudit = lieudit;
this.station = station;
this.milieu = milieu;
this.commentaire = commentaire;
this.date = date;
this.numeroOrdre = numeroOrdre;
}
 
 
public Observation(Observation[] listeObservation) {
this.listeObservation=listeObservation;
}
 
public Observation[] getListeObservation() {
return listeObservation;
}
 
 
public String getNomSaisi() {
return nomSaisi;
}
 
}
/trunk/src/org/tela_botanica/client/modeles/ImageUploaderAsynchroneDAO.java
New file
0,0 → 1,173
package org.tela_botanica.client.modeles;
 
import org.tela_botanica.client.image.ImageModele;
 
import com.gwtext.client.core.UrlParam;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.WindowListenerAdapter;
import com.gwtextux.client.widgets.upload.UploadDialog;
import com.gwtextux.client.widgets.upload.UploadDialogListenerAdapter;
 
 
/**
* DAO un peu particulier car il crée une fenetre d'upload différente
* suivant que le plugin Java est détecté ou non
*
*
*/
public class ImageUploaderAsynchroneDAO {
/**
* Modele associé au DAO
*/
private static ImageModele iModele ;
public ImageUploaderAsynchroneDAO(ImageModele im)
{
iModele = im ;
}
/**
* Setteur pour le modele
* @param im le modèle à associer au DAO
*/
public void setIModele(ImageModele im)
{
iModele = im ;
}
/**
* Crée un panel d'upload simple aux fonctions réduites mais utilisant uniquement javascript
* (pour les utilisateurs qui n'ont pas java)
*/
@SuppressWarnings("unused")
private static void appelerUploadSimple()
{
UploadDialog up = new UploadDialog("Upload simple de fichiers") ;
up.setUrl(iModele.getConfig().getServiceBaseUrl()+"/InventoryImage");
UrlParam id = new UrlParam("identifiant",iModele.getIdentifiant()) ;
UrlParam[] params = {id} ;
up.setBaseParams(params);
up.setModal(true) ;
up.addListener(new UploadDialogListenerAdapter() {
public void onClose(Panel panel) {
iModele.requeteTerminee() ;
}
 
public void onUploadComplete(UploadDialog source) {
iModele.requeteTerminee() ;
}
 
});
up.show();
}
/**
* Crée une fenêtre contenant une applet java pour uploader plusieurs fichiers à la fois avec quelques
* fonctions avancées (nécessite le plugin java pour le navigateur)
*/
@SuppressWarnings("unused")
private 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=\""+iModele.getConfig().getServiceBaseUrl()+"/InventoryImage/\">";
final String paramUploadPolicy = "<param name=\"uploadPolicy\" value=\"PictureUploadPolicy\">";
final String paramMaxChunkSize = "<param name=\"maxChunkSize\" value=\"0\">";
final String paramMaxFileSize = "<param name=\"maxFileSize\" value=\"10000000\">";
final String paramTransmitMetaData = "<param name=\"pictureTransmitMetadata\" value=\"true\">";
final String paramFilesPerRequest = "<param name=\"nbFilesPerRequest\" value=\"1\">";
final String paramAllowedExtensions = "<param name=\"allowedFileExtensions\" value=\"jpg/jpeg/\">";
final String paramUploadSuccess = "<param name=\"stringUploadSuccess\" value=\"OK\">" ;
final String paramShowLogWindow = "<param name=\"showLogWindow\" value=\"false\">";
final String paramFormdata = "<param name=\"formData\" value=\"postid\">" ;
final String finApplet = "</applet>";
 
final String appelApplet = applet
+ paramPostTarget
+ paramUploadPolicy
+ paramMaxChunkSize
+ paramMaxFileSize
+ paramTransmitMetaData
+ paramFilesPerRequest
+ paramAllowedExtensions
+ paramUploadSuccess
+ paramShowLogWindow
+paramFormdata
+ finApplet;
final String htmlForm =
"<form method=\"post\" name=\"postid\">"
+"<input type=\"hidden\" name=\"identifiant\" value=\""+iModele.getIdentifiant()+"\">"
+"</form>" ;
 
nPan.setHtml(warning+appelApplet+htmlForm);
nPan.setModal(true) ;
nPan.addListener(new WindowListenerAdapter() {
 
 
public void onClose(Panel panel) {
iModele.requeteTerminee() ;
}
});
nPan.show();
}
/**
* Fonction javascript native qui détecte la présence du plugin java pour le navigateur
* et appelle la méthode d'upload adaptée (appelerUploadSimple ou appelerUploadMultiple)
*/
public static native void choisirMethodeUpload() /*-{
var agt=navigator.userAgent.toLowerCase();
var ie = (agt.indexOf("msie") != -1);
var ns = (navigator.appName.indexOf("Netscape") != -1);
var win = ((agt.indexOf("win")!=-1) || (agt.indexOf("32bit")!=-1));
var mac = (agt.indexOf("mac")!=-1);
function detectIE(ClassID,name) { result = false; document.write('<SCRIPT LANGUAGE=VBScript>\n on error resume next \n result = IsObject(CreateObject("' + ClassID + '"))</SCRIPT>\n'); if (result) return name+','; else return ''; }
function detectNS(ClassID,name) { n = ""; if (nse.indexOf(ClassID) != -1) if (navigator.mimeTypes[ClassID].enabledPlugin != null) n = name+","; return n; }
if (ie && win) { pluginlist = detectIE("Adobe.SVGCtl","SVG Viewer") + detectIE("SWCtl.SWCtl.1","Shockwave Director") + detectIE("ShockwaveFlash.ShockwaveFlash.1","Shockwave Flash") + detectIE("rmocx.RealPlayer G2 Control.1","RealPlayer") + detectIE("QuickTimeCheckObject.QuickTimeCheck.1","QuickTime") + detectIE("MediaPlayer.MediaPlayer.1","Windows Media Player") + detectIE("PDF.PdfCtrl.5","Acrobat Reader"); }
if (ns || !win) {
nse = ""; for (var i=0;i<navigator.mimeTypes.length;i++) nse += navigator.mimeTypes[i].type.toLowerCase();
pluginlist = detectNS("image/svg-xml","SVG Viewer") + detectNS("application/x-director","Shockwave Director") + detectNS("application/x-shockwave-flash","Shockwave Flash") + detectNS("audio/x-pn-realaudio-plugin","RealPlayer") + detectNS("video/quicktime","QuickTime") + detectNS("application/x-mplayer2","Windows Media Player") + detectNS("application/pdf","Acrobat Reader");
}
pluginlist += navigator.javaEnabled() ? "Java," : "";
if (pluginlist.length > 0) pluginlist = pluginlist.substring(0,pluginlist.length-1);
if(pluginlist.indexOf("Java")!=-1)
{
@org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO::appelerUploadMultiple()() ;
}
else
{
@org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO::appelerUploadSimple()() ;
}
}-*/;
 
}
/trunk/src/org/tela_botanica/client/modeles/ImageCarnet.java
New file
0,0 → 1,367
package org.tela_botanica.client.modeles;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
 
import com.google.gwt.json.client.JSONObject;
/**
*
* Classe representant une image du carnet,
* elle ne contient pas d'image à proprement parler mais
* plutôt les informations associées ainsi que l'url distante.
* C'est une table de hachage qui contient des paires propriété/valeur
*
*/
public class ImageCarnet extends HashMap<String, String> {
 
/**
*
*/
private static final long serialVersionUID = -6220175386957259859L;
 
/**
* Constructeur avec un objet JSON
* @param image
*/
public ImageCarnet(JSONObject image)
{
// l'objet JSON est une table de hachage
Set<String> im = image.keySet() ;
// on la parcourt pour chaque clé
for (Iterator<String> iterator = im.iterator(); iterator.hasNext();) {
// si elle est associée à une valeur, on l'ajoute
String key = iterator.next();
if(image.get(key).isString() != null)
{
String valeur = image.get(key).isString().stringValue() ;
this.put(key, valeur) ;
}
else
{
// sinon on ajoute la clé avec une valeur vide
String valeur = " " ;
this.put(key, valeur) ;
}
}
 
}
/**
* Surcharge de toString qui affiche toutes les propriétés de l'image
*/
public String toString()
{
String valeur = " ";
for (Iterator<String> iterator = this.keySet().iterator(); iterator.hasNext();) {
String key = iterator.next();
if(this.get(key) != null)
{
valeur += "cle : "+key+" valeur :"+this.get(key)+"\n" ;
}
}
return valeur ;
}
/**
* Pour éviter que l'on traite des valeurs nulles à l'affichage
* on passe par cette fonction qui retire les charactères nuls qui font planter
* l'affichage, il ne faut pas utiliser get directement
* @param cle
* @return la valeur associée à la clé
*/
public String renvoyerValeurCorrecte(String cle)
{
if(this.containsKey((cle)))
{
String valeur = this.get(cle) ;
if(valeur.equals("null") || valeur == null)
{
return " " ;
}
else
{
char nullChar = '\u0000' ;
String sNull = ""+nullChar ;
valeur = valeur.replaceAll(sNull, "") ;
return valeur ;
}
}
else
{
return " " ;
}
}
 
/**
* Acesseur pour l'id de l'image
* @return l'id de l'image
*/
public String getId() {
return renvoyerValeurCorrecte("ci_id_image") ;
}
/**
* Acesseur pour le numero d'ordre de l'image
* @return l'ordre de l'image
*/
public String getOrdre() {
return renvoyerValeurCorrecte("ci_ordre") ;
}
/**
* Base de l'url serveur pour les images
* @return url racine pour les images
*/
public String getBaseUrl()
{
return "http://162.38.234.9/Documents/images_serveur/" ;
}
/**
* Renvoie le nom de base du fichier image et ses sous dossier
* @return le nom de base du fichier de type (XXX_XXX_XXX), et ses sous dossier
*/
public String[] getBaseFileName()
{
String id = getId() ;
int maxZeros = 9 - id.length() ;
for(int i = 0 ; i < maxZeros ; i++)
{
id = "0"+id ;
}
String dossierNv1 = id.substring(0, 3) ;
String dossierNv2 = id.substring(3, 6) ;
String fichierNv = id.substring(6, 9) ;
String nomFichier = dossierNv1+"_"+dossierNv2+"_"+fichierNv ;
String[] infosFichier = {nomFichier , dossierNv1 , dossierNv2} ;
return infosFichier ;
}
 
/**
* Renvoie le chemin et nom du fichier grand format
* @return le chemin du fichier grand format
*/
public String getLUrl() {
String[] infosFichier = getBaseFileName() ;
return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/L/"+infosFichier[0]+"_L.jpg" ;
}
/**
* Renvoie le chemin et nom du fichier petit format
* @return le chemin du fichier petit format
*/
public String getSUrl() {
String[] infosFichier = getBaseFileName() ;
return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/S/"+infosFichier[0]+"_S.jpg" ;
}
/**
* Renvoie le chemin et nom du fichier moyen format
* @return le chemin du fichier moyen format
*/
public String getMUrl() {
String[] infosFichier = getBaseFileName() ;
return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/M/"+infosFichier[0]+"_M.jpg" ;
}
/**
* Renvoie la taille de l'image
* @return un tableau de deux string contenant la hauteur puis la largeur
*/
public String[] getTailleImage()
{
String[] XY = { renvoyerValeurCorrecte("ci_meta_height") , renvoyerValeurCorrecte("ci_meta_width") } ;
return XY ;
}
public String[] getNote()
{
String[] note = {renvoyerValeurCorrecte("ci_note_image") } ;
return note ;
}
/**
* Renvoie la date exif associée à l'image
* @return la date associée à l'image
*/
public String getDate() {
return renvoyerValeurCorrecte("ci_meta_date") ;
}
 
/**
* Renvoie la ville associée à l'image
* @return la ville iptc
*/
public Object getIptcCity() {
return renvoyerValeurCorrecte("ci_meta_iptc_city") ;
}
 
/**
* Renvoie le fabricant de l'appareil
* @return le fabricant
*/
public String getMake() {
return renvoyerValeurCorrecte("ci_meta_make") ;
}
 
/**
* Renvoie le modele de l'appareil
* @return le modele
*/
public String getModel() {
return renvoyerValeurCorrecte("ci_meta_model") ;
}
/**
* Renvoie un tableau nom / valeur de toutes les metadonnées Iptc
* @return les métadonnées iptc
*/
public String[][] getMetadonnesIptc() {
String[][] metaIptc = new String[14][2] ;
int elem = 0 ;
for (Iterator<String> it = this.keySet().iterator(); it.hasNext();)
{
String key = it.next();
// on filtre le "ci"
String type[] = key.split("_",3) ;
// si c'est une metadonnee exif ou iptc
if(type[1].equals("meta"))
{
String[] genre = type[2].split("_",2) ;
if(genre[0].equals("iptc"))
{
String nom = genre[1] ;
metaIptc[elem][0] = nom ;
metaIptc[elem][1] = renvoyerValeurCorrecte(key) ;
elem++ ;
}
}
}
return metaIptc ;
}
/**
* Renvoie un tableau nom / valeur de toutes les metadonnées Exif
* @return les métadonnées Exif
*/
public String[][] getMetadonnesExif() {
String[][] metaExif = new String[31][2] ;
int elem = 0 ;
for (Iterator<String> it = this.keySet().iterator(); it.hasNext();)
{
String key = it.next();
// on filtre le "ci"
String type[] = key.split("_",3) ;
// si c'est une metadonnee exif ou iptc
if(type[1].equals("meta"))
{
String[] genre = type[2].split("_",2) ;
if(genre[0].equals("exif"))
{
String nom = genre[1] ;
metaExif[elem][0] = nom ;
metaExif[elem][1] = renvoyerValeurCorrecte(key) ;
elem++ ;
}
}
}
return metaExif ;
}
/**
* Renvoie un tableau nom / valeur contenant les infos générales
* @return les infos générales
*/
public String[][] getInfoGenerales() {
String[][] metaGen = new String[2][2] ;
metaGen[0][0] = "ci_meta_comment" ;
metaGen[0][1] = this.renvoyerValeurCorrecte("ci_meta_comment") ;
metaGen[1][0] = "ci_meta_date" ;
metaGen[1][1] = this.renvoyerValeurCorrecte("ci_meta_date") ;
return metaGen ;
}
/**
* Renvoie une string contenant les mots clés séparés par des ','
* @return les mots clés
*/
public String getMotsCles() {
return renvoyerValeurCorrecte("ci_meta_mots_cles") ;
}
/**
* Met à jour le commenentaire et la date
* @param commentaires le nouveau commentaire
* @param date la nouvelle date
*/
public void miseAJourInfoGenerales(String commentaires, String date, String note)
{
put("ci_meta_comment",commentaires) ;
put("ci_note_image",note) ;
put("ci_meta_date",date) ;
}
/**
* Met à jour les mots clés
* @param motsClesEnCours la liste de mots clés séparés par des ','
*/
public void mettreAjourMotsCles(String motsClesEnCours) {
put("ci_meta_mots_cles",motsClesEnCours) ;
}
}
/trunk/src/org/tela_botanica/client/modeles/ImageAsynchroneDAO.java
New file
0,0 → 1,165
package org.tela_botanica.client.modeles;
 
import java.util.Iterator;
 
import org.tela_botanica.client.image.ImageModele;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
 
/**
* DAO d'accès à une image, n'est utilisé que pour l'écriture et pas pour la lecture des images
* qui se fait par paquet
* @author aurelien
*
*/
public class ImageAsynchroneDAO {
 
ImageModele iModele = null ;
public ImageAsynchroneDAO(ImageModele im)
{
iModele = im ;
}
public void setIModele(ImageModele im)
{
iModele = im ;
}
/**
* Met à jour la base de données avec toutes les données d'une image
* @param ic l'image à mettre à jour
*/
public void SynchroniserBaseDeDonnees(final ImageCarnet ic)
{
String postData = "" ;
// on construit le post avec toutes les valeur de l'image
for(Iterator<String> imgIt = ic.keySet().iterator();imgIt.hasNext();)
{
String key = imgIt.next() ;
String valeur = ic.renvoyerValeurCorrecte(key) ;
postData += "&"+key+"="+valeur ;
 
}
 
// et on envoie une requête asynchrone
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele.getConfig().getServiceBaseUrl()+"/inventoryImage/"+iModele.getIdentifiant()+"/") ;
try {
rb.sendRequest(postData, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
public void onResponseReceived(Request request, Response response) {
if(response.getText().equals("OK"))
{
return ;
}
else
{
com.google.gwt.user.client.Window.alert("Problème lors de la mise à jour des données") ;
}
}
}) ;
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* Met à jour la base de données avec les mots clés associés à l'image
* @param ic l'image à mettre à jour
*/
public void SynchroniserMotsClesImageBaseDeDonnees(final ImageCarnet ic)
{
String postData = "" ;
// on récupère les mots clés de l'image et on fabrique le post
String motsCles = ic.getMotsCles() ;
String id = ic.getId() ;
postData += "&ci_id_image="+id+"&ci_meta_mots_cles="+motsCles ;
 
// on envoie une requête asynchrone
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele.getConfig().getServiceBaseUrl()+"/inventoryImage/"+iModele.getIdentifiant()+"/") ;
try {
rb.sendRequest(postData, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
public void onResponseReceived(Request request, Response response) {
if(response.getText().equals("OK"))
{
return ;
}
else
{
com.google.gwt.user.client.Window.alert("Problème lors de la mise à jour des données") ;
}
}
}) ;
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* Supprime une image de la base de données
* @param ic l'image à supprimer
*/
public void supprimerBaseDeDonnees(final ImageCarnet ic)
{
// le post contient l'action delete pour JREST (qui ne gère pas DELETE comme une requête à part entière)
String postData = "" ;
postData += "&action=DELETE" ;
// on envoie un post avec l'id de l'image à supprimer
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele.getConfig().getServiceBaseUrl()+"/inventoryImage/"+iModele.getIdentifiant()+"/"+ic.getId()) ;
try {
rb.sendRequest(postData, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
public void onResponseReceived(Request request, Response response) {
if(response.getText().equals("OK"))
{
return ;
}
else
{
com.google.gwt.user.client.Window.alert("Problème lors de la mise à jour des données") ;
}
}
}) ;
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/trunk/src/org/tela_botanica/client/modeles/ListeImageCarnet.java
New file
0,0 → 1,55
package org.tela_botanica.client.modeles;
 
import java.util.HashMap;
 
/**
* table de hachage composée d'ImageCarnet, renvoyé par les objets de type DAO
* pour les images.
* La clé est l'identifiant de l'image dans la base de données, et la valeur un objet
* de type ImageCarnet.
* GWT ne supporte pas encore les type paramètres mais quand il le fera il faudra créer la HashMap
* avec <String,ImageCarnet>
* @author aurelien
*
*/
public class ListeImageCarnet extends HashMap<String, ImageCarnet> {
/**
*
*/
private static final long serialVersionUID = 2715320270773281540L;
 
/**
* Constructeur sans paramètres
*/
public ListeImageCarnet()
{
super();
}
/**
* Constructeur avec paramètre
* @param taille la taille de la table de hachage
*/
public ListeImageCarnet(int taille)
{
super(taille);
}
/**
* Constructeur avec paramètre
* @param ic un tableau d'ImageCarnet
*/
public ListeImageCarnet(ImageCarnet[] ic)
{
super() ;
for (int i = 0; i < ic.length; i++)
{
if(ic[i] != null && ic[i] instanceof ImageCarnet)
{
this.put(ic[i].getOrdre(),ic[i]);
}
}
}
 
}
/trunk/src/org/tela_botanica/client/modeles/ListeImageAsynchroneDAO.java
New file
0,0 → 1,237
package org.tela_botanica.client.modeles;
 
import java.util.Iterator;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONValue;
 
/**
* Data Object Access communiquant avec le serveur jrest fournissant la liste des images
* répondant à des critères donné
* @author aurelien
*
*/
public class ListeImageAsynchroneDAO {
/**
* Le modèle associé au DAO
*/
ImageModele iModele = null ;
public ListeImageAsynchroneDAO(ImageModele im)
{
iModele = im ;
}
/**
* Setteur pour le modèle
* @param im le modèle à associer
*/
public void setIModele(ImageModele im)
{
iModele = im ;
}
/**
* Envoie une requete au serveur jrest pour obtenir une liste d'images correspondant à des critères demandés
* @param r le rafraichissable qui a demandé les données
* @param criteres un tableau contenant les critères de selections
*/
public void ObtenirListeImages(final Rafraichissable r, String[][] criteres)
{
String requete = "" ;
// on construit les paramètres du get
if(criteres != null)
{
for (int i = 0; i < criteres.length; i++) {
if(!criteres[i][1].equals(""))
{
if(i!= 0)
{
requete += "&";
}
requete += criteres[i][0]+"="+criteres[i][1] ;
}
}
}
// on envoie le get asynchrone
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,iModele.getConfig().getServiceBaseUrl()+"/InventoryImageList/"+iModele.getIdentifiant()+"/"+requete) ;
try {
rb.sendRequest(null , new RequestCallback() {
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
public void onResponseReceived(Request request, Response response) {
final ListeImageCarnet photoData ;
 
final JSONValue responseValue = JSONParser.parse(response.getText());
// si c'est un tableau
if (responseValue.isArray() != null) {
final JSONArray reponse = responseValue.isArray();
 
final int taillemax = reponse.size();
photoData = new ListeImageCarnet(taillemax);
// on le parcourt
for (int j = 0; j < taillemax ; j++) {
JSONObject image = (JSONObject)reponse.get(j) ;
ImageCarnet im = new ImageCarnet(image) ;
// et on en extrait les données pour construire la liste d'image
photoData.put(im.getOrdre(),im) ;
}
}
else
{
// si c'est un objet alors il n'y a qu'une réponse
if(responseValue.isObject() != null)
{
photoData = new ListeImageCarnet(1);
ImageCarnet im = new ImageCarnet(responseValue.isObject()) ;
// on crée une liste de 1 élement auquel on ajoute ce qui a été reçu
photoData.put(im.getOrdre(),im) ;
}
else
{
// sinon on crée une liste vide
photoData = new ListeImageCarnet(0) ;
}
}
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est
// le premier à les recevoir
r.rafraichir(photoData,true);
}
}) ;
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* Met à jour les valeurs d'une liste d'image donnée dans la base de données
* @param li la liste d'image à synchroniser avec la base
*/
public void SynchroniserBaseDeDonnees(ListeImageCarnet li)
{
// on parcourt toute la liste d'image
for(Iterator<String> listIt = li.keySet().iterator() ; listIt.hasNext() ;)
{
String postData = "" ;
ImageCarnet enCours = li.get(listIt.next()) ;
// pour chaque image on extrait les informations
for(Iterator<String> imgIt = enCours.keySet().iterator();imgIt.hasNext();)
{
// qu'on place dans le poste
String key = imgIt.next() ;
String valeur = enCours.renvoyerValeurCorrecte(key) ;
valeur.replaceAll("'", "\'") ;
postData += "&"+key+"="+enCours.renvoyerValeurCorrecte(key) ;
}
// on fait un post asynchrone et on les envoie à jrest
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,iModele.getConfig().getServiceBaseUrl()+"/inventoryImage/"+iModele.getIdentifiant()+"/") ;
try {
rb.sendRequest(postData, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
}
 
public void onResponseReceived(Request request,
Response response) {
if(response.getText().equals("OK"))
{
return ;
}
else
{
com.google.gwt.user.client.Window.alert("Problème lors de la mise à jour des données") ;
}
}
}) ;
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* Supprime des image sur le serveur par rapport à leur identifant
* @param ids un tableau d'identifiants d'images à supprimer
*/
public void supprimerBaseDeDonnees(String[] ids)
{
String postData = "" ;
// on fait un delete dans le post (jrest ne gère pas delete comme une action à part entière)
postData += "&action=DELETE" ;
String uid = "" ;
// on concatène les ids
for (int i = 0; i < ids.length; i++) {
uid += ids[i]+"," ;
}
// et on envoie ça au serveur
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,iModele.getConfig().getServiceBaseUrl()+"/inventoryImageList/"+iModele.getIdentifiant()+"/"+uid) ;
try {
rb.sendRequest(postData, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
public void onResponseReceived(Request request, Response response) {
// quand la requête est éxecutée on le signale au modèle poru qu'il mette à jour les données
// et en notifie le médiateur
iModele.requeteTerminee() ;
}
}) ;
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
}
/trunk/src/org/tela_botanica/client/modeles/NombreImageAsynchroneDAO.java
New file
0,0 → 1,102
package org.tela_botanica.client.modeles;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
/**
* DAO qui renvoie le nombre d'image associées à différents critères donnés (utile pour la pagination)
* @author aurelien
*
*/
public class NombreImageAsynchroneDAO {
 
/**
* Le modèle associé au DAO
*/
private ImageModele iModele = null ;
public NombreImageAsynchroneDAO(ImageModele im)
{
iModele = im ;
}
/**
* Setteur pour le modèle
* @param im le modèlme à associer
*/
public void setIModele(ImageModele im)
{
iModele = im ;
}
/**
* Envoie une requete au serveur jrest pour obtenir le nombre d'images correspondant
* à des critères données en paramètres
* @param r le rafraichissable qui demande la mise à jour
* @param criteres un tableau nom/valeur des critères pour les images
*/
public void obtenirNombreImages(final Rafraichissable r, String[][] criteres)
{
String requete = "" ;
if(criteres != null)
{
// on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...)
for (int i = 0; i < criteres.length; i++) {
if(!criteres[i][1].equals(""))
{
if(i!= 0)
{
requete += "&";
}
requete += criteres[i][0]+"="+criteres[i][1] ;
}
}
}
// on fait un get asynchrone
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele.getConfig().getServiceBaseUrl()+"/InventoryImageCount/"+iModele.getIdentifiant()+"/"+requete) ;
try {
rb.sendRequest(null, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
public void onResponseReceived(Request request, Response response) {
final JSONValue responseValue = JSONParser.parse(response.getText());
// si la requete se passe bien on reçoit un tableau JSON
if(responseValue.isArray() != null)
{
// qui contient une valeur : le nombre d'images correspondant au critères
JSONValue res = responseValue.isArray().get(0) ;
JSONString reponseNombre = res.isString() ;
int maxImages = Integer.parseInt(reponseNombre.stringValue()) ;
int[] nbImages = {maxImages} ;
// on le met dans un tableau d'entiers qu'on transmet au demandeur de la mise à jour
r.rafraichir(nbImages, true) ;
}
}
}) ;
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/trunk/src/org/tela_botanica/client/modeles/Configuration.java
New file
0,0 → 1,35
package org.tela_botanica.client.modeles;
 
import com.google.gwt.i18n.client.Dictionary;
 
/**
* Classe chargeant certains paramètres de configuration à partir d'un fichier javascript (config.js)
* @author aurelien
*
*/
public class Configuration {
/**
* L'url de base du serveur jrest
*/
private String serviceBaseUrl ;
/**
* Constructeur sans argument
*/
public Configuration()
{
// on utilise le dictionnaire d'internationalisation pour lire les variables du fichier javascript
serviceBaseUrl = Dictionary.getDictionary("configuration").get("serviceBaseUrl") ;
}
/**
* Accesseur pour l'url de base du serveur jrest
* @return une url de la forme http://emplacement_serveur/jrest
*/
public String getServiceBaseUrl()
{
return serviceBaseUrl ;
}
 
}
/trunk/src/org/tela_botanica/client/modeles/MotsClesAsynchroneDAO.java
New file
0,0 → 1,226
package org.tela_botanica.client.modeles;
 
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.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 ;
public MotsClesAsynchroneDAO(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 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,iModele.getConfig().getServiceBaseUrl()+"/InventoryKeyWordList/"+iModele.getIdentifiant()) ;
try {
rb.sendRequest(null, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
public void onResponseReceived(Request request, Response response) {
final JSONValue responseValue = JSONParser.parse(response.getText());
// si la requête est un succès on reçoit un tableau
if (responseValue.isArray() != null) {
final JSONArray reponse = responseValue.isArray();
// et on met à jour le demandeur des données
r.rafraichir(reponse, true) ;
}
}
}) ;
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* Envoie requete au serveur jrest pour ajouter un mot clé
* @param motcle le mots clés à ajouter avec son parent et son identifiant
*/
public void ajouterBaseDeDonnees(String motcle)
{
if(!motcle.equals(""))
{
String postData = motcle ;
// on fait un post asynchrone
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,iModele.getConfig().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,iModele.getConfig().getServiceBaseUrl()+"/InventoryKeyWordList/"+iModele.getIdentifiant()+"/"+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,iModele.getConfig().getServiceBaseUrl()+"/InventoryKeyWordList/"+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) {
// 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,iModele.getConfig().getServiceBaseUrl()+"/InventoryKeyWordList/"+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) {
// TODO Auto-generated method stub
}
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
 
}
/trunk/src/org/tela_botanica/client/modeles/UtilisateurAsynchroneDAO.java
New file
0,0 → 1,117
package org.tela_botanica.client.modeles;
 
/**
* Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour
*
*/
 
import org.tela_botanica.client.interfaces.iRetourUtilisateur;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONBoolean;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
import com.google.gwt.user.client.HTTPRequest;
import com.google.gwt.user.client.ResponseTextHandler;
 
public class UtilisateurAsynchroneDAO {
 
/**
* Constructeur
*/
public UtilisateurAsynchroneDAO() {
}
/**
* Methode de classe d'appel du service gestion identification
* @param baseURL : URL du service
* @param retour : methode appelle en retour d'appel
*/
public void getUtilisateur(String baseURL, final iRetourUtilisateur retour) {
 
// Recherche identifiant utilisateur identifie
 
HTTPRequest.asyncGet(baseURL + "/User/", new ResponseTextHandler() {
 
public void onCompletion(String str) {
JSONValue jsonValue = JSONParser.parse(str);
JSONArray jsonArray;
if ((jsonArray = jsonValue.isArray()) != null) {
String identifiant = ((JSONString) jsonArray.get(0))
.stringValue(); // Identifiant utilisateur ou
// identifiant de session si non
// identifie
boolean identifie = ((JSONBoolean) jsonArray.get(1))
.booleanValue(); // Drapeau leve si utilisateur
// deja identifie
retour.onRetour(new Utilisateur(identifiant, identifie));
}
}
});
 
}
 
 
 
public void deconnecterUtilisateur(String baseURL, final iRetourUtilisateur retour, String user) {
 
HTTPRequest.asyncGet(baseURL + "/User/" + user ,
new ResponseTextHandler() {
 
public void onCompletion(String str) {
JSONValue jsonValue = JSONParser.parse(str);
JSONArray jsonArray;
if ((jsonArray = jsonValue.isArray()) != null) {
String identifiant = ((JSONString) jsonArray.get(0))
.stringValue(); // Identifiant utilisateur ou
// identifiant de session si non
// identifie
boolean identifie = ((JSONBoolean) jsonArray.get(1))
.booleanValue(); // Drapeau leve si utilisateur
// deja identifie
 
retour.onRetour(new Utilisateur(identifiant, identifie));
}
}
});
}
 
 
 
public void connecteUtilisateur(String baseURL,final iRetourUtilisateur retour, String login, String password) {
 
HTTPRequest.asyncGet(baseURL + "/User/" + login + "/" + password ,
new ResponseTextHandler() {
 
public void onCompletion(String str) {
JSONValue jsonValue = JSONParser.parse(str);
JSONArray jsonArray;
if ((jsonArray = jsonValue.isArray()) != null) {
String identifiant = ((JSONString) jsonArray.get(0))
.stringValue(); // Identifiant utilisateur ou
// identifiant de session si non
// identifie
boolean identifie = ((JSONBoolean) jsonArray.get(1))
.booleanValue(); // Drapeau leve si utilisateur
// deja identifie
 
retour.onRetour(new Utilisateur(identifiant, identifie));
}
}
});
 
}
 
}
/trunk/src/org/tela_botanica/client/modeles/ObservationAsynchroneDAO.java
New file
0,0 → 1,112
package org.tela_botanica.client.modeles;
 
/**
* Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour
*
*/
 
import org.tela_botanica.client.Util;
import org.tela_botanica.client.interfaces.iRetourObservation;
 
import com.google.gwt.http.client.URL;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONNumber;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
import com.google.gwt.user.client.HTTPRequest;
import com.google.gwt.user.client.ResponseTextHandler;
 
public class ObservationAsynchroneDAO {
 
/**
* Constructeur
*/
public ObservationAsynchroneDAO() {
}
public void getNombreObservation(String baseURL, final iRetourObservation retour, String identifiant, String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre) {
 
HTTPRequest.asyncGet(baseURL + "/InventoryItemList/" + identifiant + "/" + identifiantLocalite + "/" + URL.encodeComponent(localite) + "/" + annee + "/" + mois + "/" + jour + "/" + URL.encodeComponent(rechercheLibre) + "/" + URL.encodeComponent(lieudit),
new ResponseTextHandler() {
 
public void onCompletion(String str) {
 
JSONValue jsonValue = JSONParser.parse(str);
JSONNumber jsonNumber;
if ((jsonNumber = jsonValue.isNumber()) != null) {
retour.onRetour(new Observation((int) jsonNumber.getValue()));
}
}
});
 
}
 
 
 
public void getListeObservation(String baseURL,final iRetourObservation retour, String identifiant, String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre, int debut, int longueur)
{
 
HTTPRequest.asyncGet(baseURL + "/InventoryItemList/" + identifiant + "/" + identifiantLocalite + "/" + URL.encodeComponent(localite) +"/" + annee + "/" + mois + "/" + jour + "/" + URL.encodeComponent(rechercheLibre) + "/" + URL.encodeComponent(lieudit) + "/"
+ debut + "/" + longueur ,
new ResponseTextHandler() {
public void onCompletion(String str) {
 
JSONValue jsonValue = JSONParser.parse(str);
JSONArray jsonArray;
JSONArray jsonArrayNested;
if ((jsonArray = jsonValue.isArray()) != null) {
if ((jsonArray = jsonValue.isArray()) != null) {
int arraySize = jsonArray.size();
Observation[] listeObservation=new Observation[arraySize];
for (int i = 0; i < arraySize; i++) {
if ((jsonArrayNested = jsonArray.get(i).isArray()) != null) {
String transmis=((JSONString) jsonArrayNested.get(13)).stringValue();
String nomSaisi=Util.toCelString(((JSONString) jsonArrayNested.get(0)).toString());
String nomRetenu=Util.toCelString(((JSONString) jsonArrayNested.get(2)).toString());
String numeroNomenclatural=((JSONString) jsonArrayNested.get(3)).stringValue();
String numeroTaxonomique=((JSONString) jsonArrayNested.get(4)).stringValue();
String famille=Util.toCelString(((JSONString) jsonArrayNested .get(5)).toString());
String localite=Util.toCelString(((JSONString) jsonArrayNested .get(6)).toString());
String lieudit=Util.toCelString(((JSONString) jsonArrayNested .get(9)).toString());
String station=Util.toCelString(((JSONString) jsonArrayNested .get(10)).toString());
String milieu=Util.toCelString(((JSONString) jsonArrayNested .get(11)).toString());
String commentaire=Util.toCelString(((JSONString) jsonArrayNested .get(12)).toString());
String date=((JSONString) jsonArrayNested .get(8)).stringValue();
String numeroOrdre=((JSONString) jsonArrayNested.get(7)).stringValue();
listeObservation[i]=new Observation(transmis, nomSaisi, nomRetenu, numeroNomenclatural, numeroTaxonomique, famille, localite, lieudit, station, milieu, commentaire, date, numeroOrdre);
}
}
retour.onRetour(new Observation(listeObservation));
}
}
}
});
}
 
 
 
 
}
/trunk/src/org/tela_botanica/client/modeles/Utilisateur.java
New file
0,0 → 1,33
package org.tela_botanica.client.modeles;
 
public class Utilisateur {
 
private String identifiant=null;
private boolean identifie=false;
 
public Utilisateur(String identifiant, boolean identifie) {
this.identifiant=identifiant;
this.identifie=identifie;
}
 
/**
* Retourne l'identifiant de l'utilisateur identifie ou un identifiant de session
* @return String identifiant
*/
public String getIdentifiant() {
return identifiant;
}
 
/**
* Retourne vrai si utilisateur identifie
* @return boolean
*/
public boolean isIdentifie() {
return identifie;
}
}