Subversion Repositories eFlore/Applications.coel

Compare Revisions

Ignore whitespace Rev 1312 → Rev 1327

/branches/v1.0-syrah/src/org/tela_botanica/client/modeles/personne/PersonneAsyncDao.java
13,6 → 13,7
import com.extjs.gxt.ui.client.Registry;
import com.google.gwt.core.client.GWT;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONValue;
 
public class PersonneAsyncDao {
26,43 → 27,80
utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId();
}
 
public void selectionner(String personneId, String projetId, String nomComplet, final int pageCourante, final int nbElements) {
String[] parametres = {personneId, projetId, nomComplet};
/**
* @param paginationProgressive : définit le mode de consultation de la base de données
* - True : la consultation des données est progressive, ce qui signifie que la liste est chargée (paginée) au
* fur et à mesure de la consultation des données par l'utilisateur.
* - False : la consultation des données est classique : un seul appel à la base de données est effectué, le retour
* est renvoyé à l'appelant
* // FIXME : si la taille de la liste est supérieure à la limite du JREST (150), ce deuxieme mode ne fonctionne pas
*/
public void selectionner(final boolean paginationProgressive, String personneId, String projetId, String nomComplet, final int start, final int nbElements) {
 
String nom = (nomComplet == null) ? "%" : nomComplet+"%";
String[] parametres = {personneId, projetId, nom};
HashMap<String, String> restrictions = new HashMap<String, String>();
restrictions.put("start", String.valueOf(pageCourante*nbElements));
if (nbElements != -1) {
restrictions.put("limit", String.valueOf(nbElements));
}
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
// Si la requête est un succès, réception d'un tableau
if (responseValue.isArray() != null) {
final JSONArray reponse = responseValue.isArray();
/** GESTION DE LA REQUETE dans le cas d'une liste paginée progressive **/
if (paginationProgressive) {
 
/** DEFINITION DU TUPLE DE DEPART **/
restrictions.put("start", String.valueOf(start));
/** CONSTRUCTION DE LA REQUETE **/
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
 
/** ENVOI DE LA REQUETE **/
rb.envoyerRequete(null, new JsonRestRequestCallback()
{
/** RECEPTION DE LA REPONSE **/
public void surReponse(JSONValue responseValue)
{
/** Dans le cas d'une liste paginée, vueARafraichir est un objet Proxy.
* On retourne l'objet JSON au proxy afin que ce soit lui qui le traite **/
vueARafraichir.rafraichir(responseValue);
}
});
}
/** GESTION DE LA REQUETE dans le cas d'une liste NON paginée progressive **/
else {
/** DEFINITION DU TUPLE DE DEPART **/
restrictions.put("start", String.valueOf(start*nbElements));
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
// Transformation du tableau JSON réponse en ListeInstitution
Information info = new Information("liste_personne");
PersonneListe personnes;
if (reponse.get(0).isArray() != null) {
personnes = new PersonneListe(reponse);
if (responseValue != null) {
JSONObject reponseObject = responseValue.isObject();
if (reponseObject.get("personnes").isArray() != null) {
JSONArray reponse = responseValue.isArray();
// Transformation du tableau JSON réponse en ListePersonne
Information info = new Information("liste_personne");
PersonneListe personnes;
personnes = new PersonneListe(reponseObject.get("personnes").isArray(), reponseObject.get("nbElements").isNumber(), vueARafraichir);
personnes.setTaillePage(nbElements);
personnes.setPageCourante(start);
info.setDonnee(0, personnes);
// et on met à jour le demandeur des données
vueARafraichir.rafraichir(info);
}
} else {
personnes = new PersonneListe(reponse.get(1).isArray(), reponse.get(0).isNumber(), vueARafraichir);
}
personnes.setTaillePage(nbElements);
personnes.setPageCourante(pageCourante);
info.setDonnee(0, personnes);
// et on met à jour le demandeur des données
vueARafraichir.rafraichir(info);
} else {
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un tableau JSON et vaut : "+responseValue.toString(), null);
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un tableau JSON et vaut : "+responseValue.toString(), null);
}
}
}
});
});
}
}
public void ajouter(Personne personne) {
/branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/Collection.java
6,6 → 6,7
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.util.Debug;
 
import com.extjs.gxt.ui.client.data.ModelData;
import com.google.gwt.json.client.JSONObject;
 
public class Collection extends aDonnee {
22,6 → 23,12
public Collection() {
}
public Collection(ModelData model)
{
this.set("id_collection", model.get("cc_id_collection"));
this.set("nom", model.get("cc_nom"));
}
public Collection(JSONObject collection) {
initialiserModele(collection);
}
208,7 → 215,7
}
// TYPE NCD
public String getTypeNcd() {
public String getTypeNcd() {
return renvoyerValeurCorrecte("ce_type");
}
public void setTypeNcd(String typeNcd) {
/branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionAsyncDao.java
30,52 → 30,99
vueARafraichir = vueARafraichirCourrante;
utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId();
}
public void selectionner(final String projetId, final String collectionId, final String nomCollection, final int start, final int nbElements) {
 
/**
*
* @param paginationProgressive : définit le mode de consultation de la base de données
* - True : la consultation des données est progressive, ce qui signifie que la liste est chargée (paginée) au
* fur et à mesure de la consultation des données par l'utilisateur.
* - False : la consultation des données est classique : un seul appel à la base de données est effectué, le retour
* est renvoyé à l'appelant
* // FIXME : si la taille de la liste est supérieure à la limite du JREST (150), ce deuxieme mode ne fonctionne pas
*/
public void selectionner(final boolean paginationProgressive, final String projetId, final String collectionId, final String nomCollection, final int start, final int nbElements) {
 
// Ajout des paramètres et données à selectionner dans l'URL
String[] parametres = {projetId, collectionId, nomCollection};
String nom = (nomCollection == null) ? "%" : nomCollection+"%";
String[] parametres = {projetId, collectionId, nom};
HashMap<String, String> restrictions = new HashMap<String, String>();
restrictions.put("start", String.valueOf(start*nbElements));
if (nbElements != -1) {
restrictions.put("limit", String.valueOf(nbElements));
}
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
if (responseValue != null) {
// Si la requête est un succès, reception d'un objet ou d'un tableau
JSONArray responseArray = responseValue.isArray();
if (responseArray.get(1).isObject() != null) {
final JSONObject reponse = responseArray.get(1).isObject();
Collection collection = new Collection(reponse);
CollectionBotanique collectionBotanique = new CollectionBotanique(reponse);
collection.setBotanique(collectionBotanique);
Information info = new Information("selection_collection");
info.setDonnee(0, collection);
vueARafraichir.rafraichir(info);
} else if (responseValue.isArray() != null) {
final JSONArray reponse = responseArray.get(1).isArray();
CollectionListe collections = new CollectionListe(reponse, responseArray.get(0).isNumber(), vueARafraichir);
collections.setTaillePage(nbElements);
collections.setPageCourante(start);
vueARafraichir.rafraichir(collections);
 
/** GESTION DE LA REQUETE dans le cas d'une liste paginée progressive **/
if (paginationProgressive) {
 
/** DEFINITION DU TUPLE DE DEPART **/
restrictions.put("start", String.valueOf(start));
/** CONSTRUCTION DE LA REQUETE **/
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
 
/** ENVOI DE LA REQUETE **/
rb.envoyerRequete(null, new JsonRestRequestCallback()
{
/** RECEPTION DE LA REPONSE **/
public void surReponse(JSONValue responseValue)
{
/** Dans le cas d'une liste paginée, vueARafraichir est un objet Proxy.
* On retourne l'objet JSON au proxy afin que ce soit lui qui le traite **/
vueARafraichir.rafraichir(responseValue);
}
});
}
/** GESTION DE LA REQUETE dans le cas d'une liste NON paginée progressive **/
else {
/** DEFINITION DU TUPLE DE DEPART **/
restrictions.put("start", String.valueOf(start*nbElements));
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
if (responseValue != null) {
 
JSONObject responseObject = responseValue.isObject();
 
if (responseObject != null) {
// Si la réponse est un tableau, alors c'est une liste de collections qui a été retournée
if (responseObject.get("collections").isArray() != null) {
final JSONArray reponse = responseObject.get("collections").isArray();
CollectionListe collections = new CollectionListe(reponse, responseObject.get("nbElements").isNumber(), vueARafraichir);
collections.setTaillePage(nbElements);
collections.setPageCourante(start);
vueARafraichir.rafraichir(collections);
// Si la réponse est un objet, alors c'est une unique collection qui a été retournée
} else if (responseObject.get("collections").isObject() != null) {
final JSONObject reponse = responseObject.get("collections").isObject();
Collection collection = new Collection(reponse);
CollectionBotanique collectionBotanique = new CollectionBotanique(reponse);
collection.setBotanique(collectionBotanique);
Information info = new Information("selection_collection");
info.setDonnee(0, collection);
vueARafraichir.rafraichir(info);
}
} else {
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un objet ou un talbeau JSON et vaut : "+responseValue.toString(), null);
}
} else {
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un objet ou un talbeau JSON et vaut : "+responseValue.toString(), null);
// Dans le cas, où nous demandons toutes les institutions et qu'il n'y en a pas, nous retournons un objet vide
if (collectionId == null) {
CollectionListe collections = new CollectionListe(0);
vueARafraichir.rafraichir(collections);
}
}
} else {
// Dans le cas, où nous demandons toutes les institutions et qu'il n'y en a pas, nous retournons un objet vide
if (collectionId == null) {
CollectionListe collections = new CollectionListe(0);
vueARafraichir.rafraichir(collections);
}
}
}
});
});
}
}
public void ajouter(Collection collection) {
/branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/Structure.java
9,6 → 9,7
import org.tela_botanica.client.util.UtilString;
 
import com.extjs.gxt.ui.client.data.BaseModelData;
import com.extjs.gxt.ui.client.data.ModelData;
import com.google.gwt.i18n.client.DateTimeFormat;
import com.google.gwt.json.client.JSONObject;
 
31,6 → 32,12
urls = new BaseModelData();
}
public Structure(ModelData model)
{
this.set("id_structure", model.get("cs_id_structure"));
this.set("nom", model.get("cs_nom"));
}
public Structure(JSONObject institution) {
// Constructions du tableau des urls interne
urls = new BaseModelData();
/branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/StructureAsyncDao.java
10,6 → 10,7
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.personne.PersonneListe;
import org.tela_botanica.client.modeles.projet.ProjetListe;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.UtilDAO;
 
import com.extjs.gxt.ui.client.Registry;
28,60 → 29,107
public StructureAsyncDao(Rafraichissable vue) {
vueARafraichir = vue;
utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId();
GWT.log("ID utilisateur :"+utilisateurId, null);
}
public void selectionner(final String projetId, final String structureId, final String nomStructure, final int pageCourante, final int nbElements) {
String[] parametres = {projetId, structureId, nomStructure};
 
/**
*
* @param paginationProgressive : définit le mode de consultation de la base de données
* - True : la consultation des données est progressive, ce qui signifie que la liste est chargée (paginée) au
* fur et à mesure de la consultation des données par l'utilisateur.
* - False : la consultation des données est classique : un seul appel à la base de données est effectué, le retour
* est renvoyé à l'appelant
* // FIXME : si la taille de la liste est supérieure à la limite du JREST (150), ce deuxieme mode ne fonctionne pas
*/
public void selectionner(final boolean paginationProgressive, final String projetId, final String structureId, final String nomStructure, final int start, final int nbElements) {
String nom = (nomStructure == null) ? "%" : nomStructure+"%";
String[] parametres = {projetId, structureId, nom};
HashMap<String, String> restrictions = new HashMap<String, String>();
restrictions.put("start", String.valueOf(pageCourante*nbElements));
if (nbElements != -1) {
restrictions.put("limit", String.valueOf(nbElements));
}
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
if (responseValue != null) {
Information info = new Information("selection_structure");
// Si la requête est un succès, reception d'un objet ou d'un tableau
JSONArray responseArray = responseValue.isArray();
if (responseArray.get(1).isObject() != null) {
final JSONObject reponse = responseArray.get(1).isObject();
Structure structure = new Structure(reponse);
StructureConservation structureConservation = new StructureConservation(reponse);
StructureValorisation structureValorisation = new StructureValorisation(reponse);
info.setDonnee(0, structure);
info.setDonnee(1, structureConservation);
info.setDonnee(2, structureValorisation);
vueARafraichir.rafraichir(info);
} else if (responseArray.get(1).isArray() != null) {
final JSONArray reponse = responseValue.isArray();
StructureListe structures; // = new StructureListe(reponse);
if (reponse.get(1).isObject() != null) {
structures = new StructureListe(reponse.get(1).isArray());
} else {
structures = new StructureListe(reponse.get(1).isArray(), reponse.get(0).isNumber(), vueARafraichir);
/** GESTION DE LA REQUETE dans le cas d'une liste paginée progressive **/
if (paginationProgressive) {
/** DEFINITION DU TUPLE DE DEPART **/
restrictions.put("start", String.valueOf(start));
/** CONSTRUCTION DE LA REQUETE **/
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
 
/** ENVOI DE LA REQUETE **/
rb.envoyerRequete(null, new JsonRestRequestCallback()
{
/** RECEPTION DE LA REPONSE **/
public void surReponse(JSONValue responseValue)
{
/** Dans le cas d'une liste paginée, vueARafraichir est un objet Proxy.
* On retourne l'objet JSON au proxy afin que ce soit lui qui le traite **/
vueARafraichir.rafraichir(responseValue);
}
});
}
/** GESTION DE LA REQUETE dans le cas d'une liste NON paginée progressive **/
else {
/** DEFINITION DU TUPLE DE DEPART **/
restrictions.put("start", String.valueOf(start*nbElements));
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
 
public void surReponse(JSONValue responseValue) {
if (responseValue != null) {
Information info = new Information("selection_structure");
JSONObject responseObject = responseValue.isObject();
if (responseObject != null) {
// Si la réponse est un tableau, alors c'est une liste de structure qui a été retournée
if (responseObject.get("structures").isArray() != null) {
JSONObject reponse = responseObject;
StructureListe structures;
structures = new StructureListe(reponse.get("structures").isArray(), reponse.get("nbElements").isNumber(), vueARafraichir);
structures.setTaillePage(nbElements);
structures.setPageCourante(start);
info.setDonnee(0, structures);
vueARafraichir.rafraichir(structures);
// Si la réponse est un objet, alors c'est une unique structure qui a été retournée
} else if (responseObject.get("structures").isObject() != null) {
JSONObject reponse = responseObject.get("structures").isObject();
Structure structure = new Structure(reponse);
StructureConservation structureConservation = new StructureConservation(reponse);
StructureValorisation structureValorisation = new StructureValorisation(reponse);
info.setDonnee(0, structure);
info.setDonnee(1, structureConservation);
info.setDonnee(2, structureValorisation);
vueARafraichir.rafraichir(info);
}
} else {
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un objet ou un talbeau JSON et vaut : "+responseValue.toString(), null);
}
structures.setTaillePage(nbElements);
structures.setPageCourante(pageCourante);
info.setDonnee(0, structures);
vueARafraichir.rafraichir(structures);
} else {
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un objet ou un talbeau JSON et vaut : "+responseValue.toString(), null);
if (structureId == null) {
// Dans le cas, où nous demandons toutes les institutions et qu'il n'y en a pas, nous retournons un objet vide
StructureListe structures = new StructureListe(0);
vueARafraichir.rafraichir(structures);
}
}
} else {
if (structureId == null) {
// Dans le cas, où nous demandons toutes les institutions et qu'il n'y en a pas, nous retournons un objet vide
StructureListe structures = new StructureListe(0);
vueARafraichir.rafraichir(structures);
}
}
}
});
});
}
}
public void ajouter(final Structure str, StructureConservation conservation, StructureValorisation valorisation) {
/branches/v1.0-syrah/src/org/tela_botanica/client/modeles/ValeurListeAsyncDao.java
19,12 → 19,10
private static HashMap<String, Object> ontologieCache = new HashMap<String, Object>();
private static HashMap<String, HashMap<Integer, Object>> pagedOntologieCache = new HashMap<String, HashMap<Integer, Object>>();
private static final String SERVICE_NOM = "CoelValeurListe";
private Rafraichissable vueARafraichir = null;
private static ValeurListe tempListe = new ValeurListe();
private int cptPage = 0;
// FIXME : limiteJREST devrait être récupéré depuis un registre/dictionnaire
private int limiteJREST = 150;
 
public ValeurListeAsyncDao(Rafraichissable vueCourante) {
34,38 → 32,6
public static HashMap<String, Object> getOntologieCache() {
return ontologieCache;
}
 
public void chargerListe(boolean nextPage, String type, Integer cle, String abv, String idValeur, boolean pagination, String recherche, int start, int nbElements) {
/** Si nextpage est VRAI, alors cela signifie que la liste est plus grande
que la limite du JREST et l'on doit relancer une requete pour obtenir
la page suivante **/
if (nextPage) {
cptPage++;
selectionner(type, cle, abv, idValeur, pagination, recherche, cptPage*limiteJREST, limiteJREST);
}
/** Sinon cela signifie que le chargement de la liste est terminé et on peut
la mettre en cache et retourner la réponse au demandeur **/
else {
// on met en cache
String id = String.valueOf(cle);
String abreviationStr = "";
if (abv != null) {
abreviationStr = abv;
int indexPoint = abreviationStr.indexOf(".", 0);
abreviationStr = abreviationStr.substring(0, indexPoint);
id = id+abreviationStr;
}
// réinitialiser le compteur
cptPage = 0;
 
// et on met à jour le demandeur des données
if (ontologieCache.get(id) != null) {
vueARafraichir.rafraichir(ontologieCache.get(id));
}
}
}
public void obtenirListe(Integer cle) {
selectionner("id", cle, null, null, false, null, -1, -1);
81,15 → 47,54
public void selectionner(String type, Integer cle, String abv, String idValeur) {
selectionner(type, cle, abv, idValeur, false, null, -1, -1);
}
 
}
/****************************************************************************************************
** selectionner(final String type, final Integer cle, final String abv, final String idValeur, final boolean pagination, final String recherche, final int start, final int limit)
/****************************************************************************************************
* Action :
* --------
* Récupère un nombre défini de Valeurs en s'aidant du nom partiel ou complet d'une valeur.
* Cette méthode gère deux types de sélection de données :
* - la sélection en cache (ontologieCache) --> pagination = FALSE
* - la sélection "au fur et à mesure" --> pagination = TRUE
*
* Gestion du cache :
* ------------------
* - Le cache est utilisé si et seulement si 'pagination' est à FAUX car dans le cas où PAGINATION est
* à VRAI, les enregistrements sont chargés au fur et à mesure de la consultation des pages par
* l'utilisateur.
* - Si la taille de la liste chargée est supérieure au nombre maximum d'enregistrements retourné
* par le service JREST, alors on charge des blocs de valeurs jusqu'à ce que la totalité de la
* liste soit chargée.
*
* Description des paramètres :
* ----------------------------
* @param 'type' est un paramètre directement destiné au service JREST. Il permet de définir le type
* de requête SQL à exécuter.
* @param 'cle' est l'identifiant de la liste de valeurs à récupérer (cas d'un noeud dans l'arbre).
* @param 'abv' sert pour la liste des régions. Il représente l'abréviation du nom d'un pays. Ce
* paramètre est concaténé à la clé pour former une clé particulière dont on se sert pour
* stocker la liste en cache.
* @param 'idValeur' est l'identifiant de la valeur à récupérer (cas d'une feuille dans l'arbre).
* @param 'pagination' est un booléen qui définit si la requête doit être paginée ou non.
* @param 'recherche' est une chaîne de caractères représentant tout ou partie du nom d'un projet.
* Si la chaîne est vide, alors tous les projets sont recherchés.
* @param 'start' et 'limit' sont les paramètres indispensables à la pagination. 'start'
* est le paramètre qui décrit le numéro du tuple de départ et 'limit' le nombre
* d'éléments à collecter.
*
*****************************************************************************************************/
public void selectionner(final String type, final Integer cle, final String abv, final String idValeur, final boolean pagination, final String recherche, final int start, final int limit) {
 
// La cleParent en Integer est insuffisante pour les liste valeurs comme Région qui on plusieurs sections sur leur liste
// (ex : on ne sélectionne que les régions FR.__ puis les régions ES.__ sur la liste 1078 ....
/**
* La cleParent en Integer est insuffisante pour les liste valeurs comme Région qui on plusieurs
* sections sur leur liste (ex : on ne sélectionne que les régions FR.__ puis les régions ES.__ sur la liste 1078 ....
**/
final String cleParentPourCache = cle + (abv == null ? "" : abv);
final String cleParent = cle+"";
/** GESTION DU PARAMETRE 'recherche' **/
String nom = "";
if ( (recherche == null) || (recherche.equals("")) ) nom = "";
else {
96,9 → 101,9
nom = recherche+"%";
}
 
/** GESTION DU PARAMETRE 'abréviation' **/
String abreviation = "";
String paramAbv = "";
if (type.equals("ab") || type.equals("abv")) {
int positionPoint = abv.indexOf(".");
if (positionPoint != -1) abreviation = abv.substring(0, positionPoint)+"%";
106,10 → 111,11
}
paramAbv = abreviation;
 
/** GESTION DES PARAMETRES à transmettre au JREST **/
String[] parametres = {type, cleParent, paramAbv, idValeur, nom};
 
HashMap<String, String> restrictions = new HashMap<String, String>();
 
/** GESTION DE LA REQUETE dans le cas d'une liste paginée **/
if (pagination) {
 
restrictions.put("limit", String.valueOf(limit));
116,48 → 122,59
restrictions.put("start", String.valueOf(start));
restrictions.put("orderby", "cmlv_nom");
/** CONSTRUCTION DE LA REQUETE **/
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
/** ENVOI DE LA REQUETE **/
rb.envoyerRequete(null, new JsonRestRequestCallback()
{
@Override
/** RECEPTION DE LA REPONSE **/
public void surReponse(JSONValue responseValue)
{
{
/** Dans le cas d'une liste paginée, vueARafraichir est un objet Proxy.
* On retourne l'objet JSON au proxy afin que ce soit lui qui le traite **/
vueARafraichir.rafraichir(responseValue);
}
});
}
/** GESTION DE LA REQUETE dans le cas d'une liste NON paginée **/
else
{
/** si start est supérieur à zéro, alors cela signifie que l'on doit charger une nouvelle page **/
boolean nextPage = (start > 0);
if (nextPage)
{
/** définition des contraintes sur la requête SQL **/
if (nextPage) {
restrictions.put("start", String.valueOf(start));
restrictions.put("limit", String.valueOf(limit));
restrictions.put("orderby", "cmlv_nom");
}
else
{
else {
restrictions.put("orderby", "cmlv_nom");
}
// si l'on est pas dans un processus de récupération d'une liste
// et si le cache contient déjà la liste recherchée
if (ontologieCache.containsKey(cleParentPourCache) && !nextPage)
{
/** Si l'on est pas dans un processus de récupération d'une liste, alors si le cache contient déjà la liste recherchée **/
if (!nextPage && ontologieCache.containsKey(cleParentPourCache)) {
/** on retourne à la vue la liste contenue dans le cache **/
vueARafraichir.rafraichir(ontologieCache.get(cleParentPourCache));
}
else
{
}
/** Si l'on est en train de récupérer une liste (c-a-d que l'on est en train de charger des blocs de données afin de récupérer totalement une liste) **/
else {
/** CONSTRUCTION DE LA REQUETE **/
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback()
{
@Override
public void surReponse(JSONValue responseValue)
{
if (responseValue.isObject() != null)
{
/** Récuperation des différents paramètres de la réponse JSON **/
/** ENVOI DE LA REQUETE **/
rb.envoyerRequete(null, new JsonRestRequestCallback() {
/** RECEPTION DE LA REPONSE **/
public void surReponse(JSONValue responseValue) {
/** Si la réponse n'est pas vide **/
if (responseValue.isObject() != null) {
/** Récupération des différents paramètres de la réponse JSON **/
final JSONObject reponse = responseValue.isObject();
JSONString listeId = reponse.get("id").isString();
JSONArray listeValeurs = reponse.get("valeurs").isArray();
175,7 → 192,7
abreviationStr = "";
}
 
/** si l'on a bien reçu une liste de valeurs **/
/** Si l'on a bien reçu une liste de valeurs **/
if (listeId != null)
{
/** Transformation du tableau JSON réponse en ValeurListe **/
203,4 → 220,50
}
}
}
/********************************************************************************************************
* Action :
* --------
* Clotûre le chargement d'une liste de valeurs si le chargement est terminé, ou lance le chargement
* du prochain bloc de données si la liste n'est pas chargée en totalité.
*
* Paramètres :
* ------------
* @param nextPage : est VRAI s'il faut faut continuer de charger la liste car elle n'est pas entièrement chargée et FAUX sinon
* @param Tous les autres paramètres sont les mêmes que pour la méthode 'selectionner'
*
*********************************************************************************************************/
public void chargerListe(boolean nextPage, String type, Integer cle, String abv, String idValeur, boolean pagination, String recherche, int start, int nbElements) {
/** Si nextpage est VRAI, alors cela signifie que l'on doit relancer une requete pour obtenir
la page suivante **/
if (nextPage) {
cptPage++;
selectionner(type, cle, abv, idValeur, pagination, recherche, cptPage*limiteJREST, limiteJREST);
}
/** Sinon cela signifie que le chargement de la liste est terminé et on peut
la mettre en cache et retourner la réponse au demandeur **/
else {
// recupération de l'idenfiant de la liste
String id = String.valueOf(cle);
// gestion de l'abréviation pour la liste des régions
String abreviationStr = "";
if (abv != null) {
abreviationStr = abv;
int indexPoint = abreviationStr.indexOf(".", 0);
abreviationStr = abreviationStr.substring(0, indexPoint);
id = id+abreviationStr;
}
// réinitialisation du compteur
cptPage = 0;
 
/** On retourne la liste à la vue **/
if (ontologieCache.get(id) != null) {
vueARafraichir.rafraichir(ontologieCache.get(id));
}
}
}
}
/branches/v1.0-syrah/src/org/tela_botanica/client/modeles/projet/Projet.java
2,6 → 2,7
 
import org.tela_botanica.client.modeles.aDonnee;
 
import com.extjs.gxt.ui.client.data.ModelData;
import com.google.gwt.json.client.JSONObject;
 
public class Projet extends aDonnee {
17,6 → 18,12
initialiserModele(liste);
}
public Projet(ModelData model)
{
this.set("id_projet", model.get("cpr_id_projet"));
this.set("nom", model.get("cpr_nom"));
}
@Override
protected String getPrefixe() {
return PREFIXE;
/branches/v1.0-syrah/src/org/tela_botanica/client/modeles/projet/ProjetAsyncDao.java
9,6 → 9,7
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.structure.StructureListe;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.UtilDAO;
 
import com.extjs.gxt.ui.client.Registry;
29,54 → 30,98
utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId();
}
public void selectionner(final String projetId, final String nom, final int pageCourante, final int nbElements) {
/**
* @param paginationProgressive : définit le mode de consultation de la base de données
* - True : la consultation des données est progressive, ce qui signifie que la liste est chargée (paginée) au
* fur et à mesure de la consultation des données par l'utilisateur.
* - False : la consultation des données est classique : un seul appel à la base de données est effectué, le retour
* est renvoyé à l'appelant
* // FIXME : si la taille de la liste est supérieure à la limite du JREST (150), ce deuxieme mode ne fonctionne pas
*/
public void selectionner(final boolean paginationProgressive, final String projetId, final String nomProjet, final int start, final int nbElements) {
String nom = (nomProjet == null) ? "%" : nomProjet+"%";
String[] param = {projetId, nom};
HashMap<String, String> restrictions = new HashMap<String, String>();
restrictions.put("start", String.valueOf(pageCourante*nbElements));
if (nbElements != -1) {
restrictions.put("limit", String.valueOf(nbElements));
}
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, param, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
if (responseValue != null) {
// Si la requête est un succès, reception d'un objet ou d'un tableau
JSONArray responseArray = responseValue.isArray();
if (responseArray.get(1).isObject() != null) {
final JSONObject reponse = responseArray.get(1).isObject();
Projet projet = new Projet(reponse);
/** GESTION DE LA REQUETE dans le cas d'une liste paginée progressive **/
if (paginationProgressive) {
 
/** DEFINITION DU TUPLE DE DEPART **/
restrictions.put("start", String.valueOf(start));
/** CONSTRUCTION DE LA REQUETE **/
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, param, restrictions);
 
/** ENVOI DE LA REQUETE **/
rb.envoyerRequete(null, new JsonRestRequestCallback()
{
/** RECEPTION DE LA REPONSE **/
public void surReponse(JSONValue responseValue)
{
/** Dans le cas d'une liste paginée, vueARafraichir est un objet Proxy.
* On retourne l'objet JSON au proxy afin que ce soit lui qui le traite **/
vueARafraichir.rafraichir(responseValue);
}
});
}
/** GESTION DE LA REQUETE dans le cas d'une liste NON paginée progressive **/
else {
/** DEFINITION DU TUPLE DE DEPART **/
restrictions.put("start", String.valueOf(start*nbElements));
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, param, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
public void surReponse(JSONValue responseValue) {
if (responseValue != null) {
Information info = new Information("selection_projet");
info.setDonnee(0, projet);
vueARafraichir.rafraichir(info);
} else if (responseArray.get(1).isArray() != null) {
final JSONArray reponse = responseValue.isArray();
ProjetListe projets;
if (responseArray.get(1).isObject() != null) {
projets = new ProjetListe(reponse.get(1).isArray());
} else {
projets = new ProjetListe(reponse.get(1).isArray(), reponse.get(0).isNumber(), vueARafraichir);
JSONObject responseObject = responseValue.isObject();
if (responseObject != null) {
// Si la réponse est un tableau, alors c'est une liste de projets qui a été retournée
if (responseObject.get("projets").isArray() != null) {
JSONArray reponse = responseObject.get("projets").isArray();
ProjetListe projets;
projets = new ProjetListe(reponse, responseObject.get("nbElements").isNumber(), vueARafraichir);
projets.setTaillePage(nbElements);
projets.setPageCourante(start);
vueARafraichir.rafraichir(projets);
// Si la réponse est un objet, alors c'est un unique projet qui a été retournée
} else if (responseObject.get("projets").isObject() != null) {
JSONObject reponse = responseObject.get("projets").isObject();
Projet projet = new Projet(reponse);
Information info = new Information("selection_projet");
info.setDonnee(0, projet);
vueARafraichir.rafraichir(info);
}
} else {
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un objet ou un tableau JSON et vaut : "+responseValue.toString(), null);
}
projets.setTaillePage(nbElements);
projets.setPageCourante(pageCourante);
vueARafraichir.rafraichir(projets);
} else {
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un objet ou un talbeau JSON et vaut : "+responseValue.toString(), null);
// Dans le cas, où nous demandons tous les projets et qu'il n'y en a pas, nous retournons un objet vide
if (projetId == null) {
ProjetListe projets = new ProjetListe(0);
vueARafraichir.rafraichir(projets);
}
}
} else {
// Dans le cas, où nous demandons tous les projets et qu'il n'y en a pas, nous retournons un objet vide
if (projetId == null) {
ProjetListe projets = new ProjetListe(0);
vueARafraichir.rafraichir(projets);
}
}
}
});
});
}
}
public void ajouter(Projet projet) {