/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) { |