Subversion Repositories eFlore/Applications.coel

Compare Revisions

No changes between revisions

Ignore whitespace Rev 1328 → Rev 1329

/trunk/src/org/tela_botanica/client/modeles/personne/PersonneAsyncDao.java
15,6 → 15,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,51 → 27,88
public PersonneAsyncDao(Rafraichissable vue) {
vueARafraichir = vue;
utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId();
}
}
/**
* @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, final Integer seqId) {
 
public void selectionner(String personneId, String projetId, String nomComplet, final int pageCourante, final int nbElements, final Integer seqId) {
String[] parametres = {personneId, projetId, nomComplet};
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
if (seqId != null) {
Reponse reponseRequete = new Reponse(info, seqId);
vueARafraichir.rafraichir(reponseRequete);
}
else {
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
if (seqId != null) {
Reponse reponseRequete = new Reponse(info, seqId);
vueARafraichir.rafraichir(reponseRequete);
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un tableau JSON et vaut : "+responseValue.toString(), null);
}
else {
vueARafraichir.rafraichir(info);
}
} else {
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un tableau JSON et vaut : "+responseValue.toString(), null);
}
}
});
});
}
}
public void ajouter(Personne personne) {
/trunk/src/org/tela_botanica/client/modeles/personne/Personne.java
218,14 → 218,51
return dateNaiss;
}
public String getDateSouple(String date) {
String valeurDate = date;
String jour = "";
String mois = "";
String annee = "";
 
// pas de date dans la BD
if (UtilString.isEmpty(valeurDate) || valeurDate.equals("0000-00-00")) {
valeurDate = "";
// YYYY
} else if (valeurDate.endsWith("00-00")) {
valeurDate = valeurDate.substring(0, 4);
if (valeurDate.matches("\\d{4}")) {
jour = "";
mois = "";
annee = valeurDate.substring(0,4);
valeurDate = annee;
}
// YYYY-MM
} else if (valeurDate.endsWith("-00")) {
valeurDate = valeurDate.substring(0, 7);
if (valeurDate.matches("\\d{4}-\\d{2}")) {
jour = "";
mois = valeurDate.substring(5,7);
annee = valeurDate.substring(0,4);
valeurDate = mois+"/"+annee;
}
}
// YYYY-MM-DD
else if (valeurDate.matches("\\d{4}-\\d{2}-\\d{2}")) {
Date objetDate = DateTimeFormat.getFormat("yyyy-MM-dd").parse(valeurDate);
DateTimeFormat fmt = DateTimeFormat.getFormat("dd/MM/yyyy");
valeurDate = fmt.format(objetDate);
}
return valeurDate;
}
public String getAnneeOuDateNaiss() {
String valeurDateNaissance = get("naissance_date");
if (!UtilString.isEmpty(valeurDateNaissance) && valeurDateNaissance.endsWith("00-00")) {
valeurDateNaissance = valeurDateNaissance.substring(0, 4);
} else if (UtilString.isEmpty(valeurDateNaissance) && valeurDateNaissance.equals("0000-00-00")) {
valeurDateNaissance = "";
}
return valeurDateNaissance;
String valeurDateNaissance = get("naissance_date");
return getDateSouple(valeurDateNaissance);
}
public void setNaissanceDate(Date naissanceDate) {
259,13 → 296,8
}
public String getAnneeOuDateDeces() {
String valeurDateDeces = get("deces_date");
if (!UtilString.isEmpty(valeurDateDeces) && valeurDateDeces.endsWith("00-00")) {
valeurDateDeces = valeurDateDeces.substring(0, 4);
} else if (UtilString.isEmpty(valeurDateDeces) && valeurDateDeces.equals("0000-00-00")) {
valeurDateDeces = "";
}
return valeurDateDeces;
String valeurDateDeces = get("deces_date");
return getDateSouple(valeurDateDeces);
}
public void setDeces(String deces) {
/trunk/src/org/tela_botanica/client/modeles/Utilisateur.java
149,7 → 149,7
* @return boolean
*/
public boolean isIdentifie() {
if (get("identifie").equals(true) && getLicence().equals("1")) {
if (get("identifie").equals(true)) {
return true;
} else {
return false;
159,7 → 159,15
public void setIdentification(Boolean bool) {
set("identifie", bool);
}
 
public boolean avoirLicenceAcceptee() {
if (getLicence().equals("1")) {
return true;
} else {
return false;
}
}
 
// LICENCE ACCEPTÉE
public void setLicence(String licence) {
this.set("licenceAcceptee", licence);
/trunk/src/org/tela_botanica/client/modeles/collection/CollectionAsyncDao.java
31,51 → 31,98
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) {
/trunk/src/org/tela_botanica/client/modeles/collection/CollectionACommentaireAsyncDao.java
32,7 → 32,7
String[] parametres = {collectionId};
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres);
Debug.log(rb.getUrl());
 
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
/trunk/src/org/tela_botanica/client/modeles/collection/CollectionAPersonneAsyncDao.java
30,7 → 30,7
String[] parametres = {collectionId, roleId};
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres);
Debug.log(rb.getUrl());
 
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
81,7 → 81,7
final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres);
String postDonneesEncodees = construirePost(personnes.getIdCollection(), personnes);
Debug.log(rb.getUrl());
 
rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
/trunk/src/org/tela_botanica/client/modeles/collection/CollectionAPublicationAsyncDao.java
30,7 → 30,7
String[] parametres = {collectionId};
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres);
Debug.log(rb.getUrl());
 
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
public void surReponse(JSONValue responseValue) {
/trunk/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 {
23,6 → 24,12
}
 
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);
}
/trunk/src/org/tela_botanica/client/modeles/structure/StructureAPersonne.java
307,4 → 307,11
public String afficherSpecialite() {
return getChaineDenormaliseUnique("specialite");
}
}
public String getDeces() {
return renvoyerValeurCorrecte("ce_deces");
}
public void setDeces(String etat) {
set("ce_deces", etat);
}
}
/trunk/src/org/tela_botanica/client/modeles/structure/StructureAPersonneAsyncDao.java
139,6 → 139,7
"&cp_truk_telephone=" + URL.encodeComponent(personnel.getTelephone()) +
"&cp_truk_courriel=" + URL.encodeComponent(personnel.getCourriel()) +
"&cp_ce_truk_specialite=" + URL.encodeComponent(personnel.getSpecialite()) +
"&cp_ce_deces=" + URL.encodeComponent(personnel.getDeces()) +
"";
return postDonnees;
}
/trunk/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();
/trunk/src/org/tela_botanica/client/modeles/structure/StructureAsyncDao.java
29,75 → 29,125
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, final Integer seqId) {
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, final Integer seqId) {
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));
restrictions.put("orderby", "cs_ville");
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);
/** 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);
 
if (seqId != null) {
Reponse reponseRequete = new Reponse(info, seqId);
vueARafraichir.rafraichir(reponseRequete);
}
else
vueARafraichir.rafraichir(info);
/** ENVOI DE LA REQUETE **/
rb.envoyerRequete(null, new JsonRestRequestCallback()
{
/** RECEPTION DE LA REPONSE **/
public void surReponse(JSONValue responseValue)
{
if (seqId != null) {
Reponse reponseRequete = new Reponse(responseValue, seqId);
vueARafraichir.rafraichir(reponseRequete);
}
/** 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 **/
else 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) {
} 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);
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);
if (seqId != null) {
Reponse reponseRequete = new Reponse(info, seqId);
vueARafraichir.rafraichir(reponseRequete);
}
else 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);
if (seqId != null) {
Reponse reponseRequete = new Reponse(info, seqId);
vueARafraichir.rafraichir(reponseRequete);
}
else 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);
 
if (seqId != null) {
Reponse reponseRequete = new Reponse(info, seqId);
vueARafraichir.rafraichir(reponseRequete);
} 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);
}
else
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);
}
} 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) {
String postDonneesEncodees = construirePost(null, str, conservation, valorisation);
 
/trunk/src/org/tela_botanica/client/modeles/ValeurListeAsyncDao.java
21,12 → 21,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) {
36,45 → 34,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, final Integer seqId) {
/** 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, seqId);
}
/** 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) {
if (vueARafraichir instanceof Sequenceur) {
vueARafraichir = (Sequenceur) vueARafraichir;
Reponse reponse = new Reponse(ontologieCache.get(id), seqId);
vueARafraichir.rafraichir(reponse);
} else {
vueARafraichir.rafraichir(ontologieCache.get(id));
}
}
}
}
public void obtenirListe(Integer cle, Integer seqId) {
selectionner("id", cle, null, null, false, null, -1, -1, seqId);
92,12 → 51,52
selectionner(type, cle, abv, idValeur, false, null, -1, -1, seqId);
}
 
/****************************************************************************************************
** 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, final Integer seqId) {
// 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 {
104,9 → 103,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)+"%";
114,10 → 113,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));
124,15 → 124,21
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)
{
{
if (vueARafraichir instanceof Sequenceur) {
Reponse reponse = new Reponse(responseValue, seqId);
vueARafraichir.rafraichir(reponse);
/** 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 **/
} else {
vueARafraichir.rafraichir(responseValue);
}
139,44 → 145,44
}
});
}
/** 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)
{
//On est à la derniere page, on peu rafraichir
if (vueARafraichir instanceof Sequenceur) {
Reponse reponse = new Reponse(ontologieCache.get(cleParentPourCache), seqId);
vueARafraichir.rafraichir(reponse);
} else {
vueARafraichir.rafraichir(ontologieCache.get(cleParentPourCache));
}
}
else
{
/** 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));
}
/** 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();
194,7 → 200,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 **/
222,4 → 228,56
}
}
}
/********************************************************************************************************
* 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, final Integer seqId) {
/** 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, seqId);
}
/** 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) {
if (vueARafraichir instanceof Sequenceur) {
vueARafraichir = (Sequenceur) vueARafraichir;
Reponse reponse = new Reponse(ontologieCache.get(id), seqId);
vueARafraichir.rafraichir(reponse);
} else {
vueARafraichir.rafraichir(ontologieCache.get(id));
}
}
}
}
}
/trunk/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;
/trunk/src/org/tela_botanica/client/modeles/projet/ProjetAsyncDao.java
29,60 → 29,105
vueARafraichir = vueARafraichirCourrante;
utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId();
}
 
public void selectionner(final String projetId, final String nom, final int pageCourante, final int nbElements, final Integer seqId) {
/**
* @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, final Integer seqId) {
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);
}
projets.setTaillePage(nbElements);
projets.setPageCourante(pageCourante);
JSONObject responseObject = responseValue.isObject();
if (seqId != null) {
Reponse retourRequete = new Reponse(projets, seqId);
vueARafraichir.rafraichir(retourRequete);
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);
if (seqId != null) {
Reponse retourRequete = new Reponse(projets, seqId);
vueARafraichir.rafraichir(retourRequete);
} else {
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 {
vueARafraichir.rafraichir(projets);
GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un objet ou un tableau 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 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) {
/trunk/src/org/tela_botanica/client/modeles/commentaire/Commentaire.java
4,6 → 4,7
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.modeles.collection.Collection;
import org.tela_botanica.client.modeles.collection.CollectionACommentaire;
import org.tela_botanica.client.util.Debug;
 
import com.google.gwt.json.client.JSONObject;
 
28,7 → 29,9
public void initialiserCommentaire(JSONObject commentaire, boolean chargerCollectionACommentaire) {
initialiserModele(commentaire);
collection = new Collection(commentaire);
if (chargerCollectionACommentaire) {
collectionACommentaire = new CollectionACommentaire(commentaire);
} else {
/trunk/src/org/tela_botanica/client/modeles/commentaire/CommentaireListe.java
5,6 → 5,7
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.aDonneeListe;
import org.tela_botanica.client.util.UtilString;
 
import com.extjs.gxt.ui.client.Registry;
import com.google.gwt.i18n.client.Dictionary;
53,11 → 54,18
private void initialiserCommentaireListe(JSONArray ListeDeCommentaires) {
boolean chargerCollectionACommentaire = true;
final int taillemax = ListeDeCommentaires.size();
for (int i = 0; i < taillemax; i++) {
JSONObject commentaireCourant = ListeDeCommentaires.get(i).isObject() ;
if (commentaireCourant != null) {
Commentaire commentaire = new Commentaire(commentaireCourant, chargerCollectionACommentaire);
this.put(commentaire.getId(), commentaire);
if (!UtilString.isEmpty(commentaire.getCollectionACommentaire().getId())) {
this.put(commentaire.getCollectionACommentaire().getId(), commentaire);
}
else {
this.put(commentaire.getId(), commentaire);
}
}
}
}
/trunk/src/org/tela_botanica/client/modeles/commentaire/CommentaireAsyncDao.java
8,7 → 8,6
import org.tela_botanica.client.http.JsonRestRequestCallback;
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.UtilDAO;
 
import com.extjs.gxt.ui.client.Registry;
37,6 → 36,8
restrictions.put("limit", String.valueOf(nbElements));
}
restrictions.put("orderby", "ccac_id_collection DESC");
final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres, restrictions);
rb.envoyerRequete(null, new JsonRestRequestCallback() {
@Override
44,6 → 45,7
if (responseValue != null) {
// Si la requête est un succès, réception d'un objet ou d'un tableau
JSONArray responseArray = responseValue.isArray();
if (responseArray.get(1).isObject() != null) {
final JSONObject reponse = responseArray.get(1).isObject();
// Transformation du tableau JSON réponse en ListeInstitution
51,7 → 53,7
// et on met à jour le demandeur des données
vueARafraichir.rafraichir(commentaire);
} else if (responseValue.isArray() != null) {
final JSONArray reponse = responseValue.isArray();
final JSONArray reponse = responseValue.isArray();
CommentaireListe commentaires;
if (reponse.get(1).isObject() != null) {
commentaires = new CommentaireListe(reponse.get(1).isArray());
/trunk/src/org/tela_botanica/client/modeles/publication/Publication.java
69,18 → 69,6
this.set("fmt_auteur", auteurFormate);
}
 
// FIXME :
// NE SERT A RIEN !
// Author : Cyprien
// Action : Cette fonction retourne l'objet de la publication (=ce dont parle la publication)
// le résultat est une chaine de caractères représentant le nom d'une collection
// ou d'une personne
public String getObjetDeLaPublication(){
String objetDeLaPublication = "";
return objetDeLaPublication;
}
 
public String getCollection() {
return renvoyerValeurCorrecte("collection");
}
/trunk/src/org/tela_botanica/client/modeles/UtilisateurAsyncDao.java
161,8 → 161,8
public void surReponse(JSONValue responseValue) {
if (responseValue.isArray() != null) {
final JSONArray reponse = responseValue.isArray();
if (reponse.get(1).isString() != null) {
String licenceAcceptee = reponse.get(1).isString().stringValue();
if (reponse.get(0).isString() != null) {
String licenceAcceptee = reponse.get(0).isString().stringValue();
Information info = new Information("maj_licence");
info.setDonnee(0, licenceAcceptee);
vueARafraichir.rafraichir(info);
/trunk/src/org/tela_botanica/client/modeles/Valeur.java
46,7 → 46,7
this.set("abreviation", abr);
this.set("description", description);
}
 
public Valeur(ModelData model)
{
this.set("id_valeur", model.get("cmlv_id_valeur"));
54,7 → 54,7
this.set("abreviation", model.get("cmlv_abreviation"));
this.set("description", model.get("cmlv_description"));
}
 
@Override
protected String getPrefixe() {
return PREFIXE;
/trunk/src/org/tela_botanica/client/modeles/.
Property changes:
Modified: svn:mergeinfo
Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles:r1292-1328