| /trunk/src/org/tela_botanica/client/modeles/Aide.java |
|---|
| New file |
| 0,0 → 1,42 |
| package org.tela_botanica.client.modeles; |
| import com.extjs.gxt.ui.client.data.BaseTreeModel; |
| public class Aide extends BaseTreeModel { |
| private static final long serialVersionUID = 4660015084509968872L; |
| public Aide() { |
| } |
| public Aide(String n) { |
| set("nom", n); |
| } |
| public Aide(String nom, String code, String auteur, String groupe) { |
| set("nom", nom); |
| set("code", code); |
| set("auteur", auteur); |
| set("groupe", groupe); |
| } |
| public String getNom() { |
| return (String) get("nom"); |
| } |
| public String getCode() { |
| return (String) get("code"); |
| } |
| public String getAuteur() { |
| return (String) get("auteur"); |
| } |
| public String getGroupe() { |
| return (String) get("groupe"); |
| } |
| public String toString() { |
| return getNom(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/Aide.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/Menu.java |
|---|
| New file |
| 0,0 → 1,50 |
| package org.tela_botanica.client.modeles; |
| import java.io.Serializable; |
| import com.extjs.gxt.ui.client.data.BaseTreeModel; |
| public class Menu extends BaseTreeModel implements Serializable { |
| /** |
| * Identifiant pour sérialisé l'objet... |
| */ |
| private static final long serialVersionUID = 4; |
| public Menu() { |
| } |
| public Menu(String nom) { |
| set("nom", nom); |
| } |
| public Menu(String nom, String code) { |
| set("nom", nom); |
| set("code", code); |
| } |
| public Menu(String nom, BaseTreeModel[] enfant) { |
| this(nom); |
| for (int i = 0; i < enfant.length; i++) { |
| add(enfant[i]); |
| } |
| } |
| public String getNom() { |
| return get("nom"); |
| } |
| public void setNom(String nom) { |
| set("nom", nom); |
| } |
| public String getCode() { |
| return get("code"); |
| } |
| public void setCode(String code) { |
| set("code", code); |
| } |
| public String toString() { |
| return getNom()+" - Nbre enfant :"+this.getChildCount(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/Menu.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/MenuApplicationId.java |
|---|
| New file |
| 0,0 → 1,12 |
| package org.tela_botanica.client.modeles; |
| public class MenuApplicationId { |
| public static final String ACCUEIL = "Accueil"; |
| public static final String PROJET = "Projets"; |
| public static final String STRUCTURE = "Structures"; |
| public static final String COLLECTION = "Collections"; |
| public static final String PERSONNE = "Personnes"; |
| public static final String PUBLICATION = "Publications"; |
| public static final String COMMENTAIRE = "Commentaires"; |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/MenuApplicationId.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/aDonnee.java |
|---|
| New file |
| 0,0 → 1,473 |
| package org.tela_botanica.client.modeles; |
| import java.io.Serializable; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TreeSet; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilArray; |
| import org.tela_botanica.client.util.UtilString; |
| import com.extjs.gxt.ui.client.core.FastMap; |
| import com.extjs.gxt.ui.client.data.BaseModelData; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * @author jpm |
| * |
| */ |
| public abstract class aDonnee extends BaseModelData implements Serializable { |
| private static final long serialVersionUID = 3527760464061629791L; |
| public static final String TYPE_AUTRE = "AUTRE"; |
| public static final String TYPE_TOTAL = "TOTAL"; |
| public static final String SEPARATEUR_TYPE_VALEUR = "##"; |
| public static final String SEPARATEUR_VALEURS = ";;"; |
| public static final String SEPARATEUR_DONNEES = "||"; |
| public static final String ETAT_AJOUTE = "A"; |
| public static final Object ETAT_MODIFIE = "M"; |
| public static final String VALEUR_NULL = "NC"; |
| public HashMap<String, String> valeursInitiales = new HashMap<String, String>(); |
| protected abstract String getPrefixe(); |
| protected abstract String[] getChampsObligatoires(); |
| public String getDateModification() { |
| return (String) renvoyerValeurCorrecte("cmhl_date_modification"); |
| } |
| public String getNotes() { |
| return (String) renvoyerValeurCorrecte("cmhl_notes"); |
| } |
| public String getIdModifierPar() { |
| return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par"); |
| } |
| public String getIdEtat() { |
| return (String) renvoyerValeurCorrecte("cmhl_ce_etat"); |
| } |
| public String getIp() { |
| return (String) renvoyerValeurCorrecte("cmhl_ip"); |
| } |
| protected void initialiserModele(JSONObject jsonObjet) { |
| // l'objet JSON est une table de hachage |
| Set<String> im = jsonObjet.keySet(); |
| valeursInitiales = new HashMap<String, String>(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| if (cle.startsWith(getPrefixe()+"_") ||cle.matches("^_.+_$")) { |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+getPrefixe()+"_", ""); |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = ""; |
| if (jsonObjet.get(cle).isString() != null) { |
| valeur = jsonObjet.get(cle).isString().stringValue(); |
| } |
| valeursInitiales.put(cleObjet, valeur); |
| this.set(cleObjet, valeur); |
| } |
| } |
| } |
| public void setValeurInitiale(String cleObjet, String valeur) { |
| } |
| /** |
| * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par |
| * cette fonction qui retire les charactères nuls qui font planter |
| * l'affichage, il ne faut pas utiliser get directement |
| * |
| * @param cle |
| * @return la valeur associée à la clé |
| */ |
| protected String renvoyerValeurCorrecte(String cle) { |
| String sortie = ""; |
| if (this.get(cle) != null) { |
| String valeur = ""+this.get(cle); |
| if (! valeur.equals("null")) { |
| char nullChar = '\u0000'; |
| String sNull = "" + nullChar; |
| valeur = valeur.replaceAll(sNull, ""); |
| sortie = valeur; |
| } |
| } |
| return sortie; |
| } |
| /** |
| * Ajoute un nouvel élément avec son type à une chaine dénormalisée. |
| * Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##". |
| * Si l'élément existe déjà, il ne sera pas ajouté. |
| * |
| * @param champ le nom du champ dénormalisé |
| * @param type le type de la valeur à ajouter |
| * @param valeur la valeur à ajouter |
| */ |
| protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) { |
| if (valeur instanceof String) { |
| String chaineExistante = renvoyerValeurCorrecte(champ); |
| if (UtilString.isEmpty(chaineExistante)) { |
| this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur); |
| } else { |
| // Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons |
| if (!chaineExistante.matches("(^|"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+valeur+"("+SEPARATEUR_VALEURS+"|$)")) { |
| this.set(champ, chaineExistante+";;"+type+SEPARATEUR_TYPE_VALEUR+valeur); |
| } |
| } |
| } |
| } |
| protected void supprimerTypeDansChaineDenormalise(String champ, String type) { |
| String chaineExistante = renvoyerValeurCorrecte(champ); |
| if (!UtilString.isEmpty(chaineExistante)) { |
| if (chaineExistante.matches("(?:^|.*"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+".*")) { |
| chaineExistante = chaineExistante.replaceFirst("(^|.*"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+".*?("+SEPARATEUR_VALEURS+".*|$)", "$1$2"); |
| chaineExistante = chaineExistante.replaceAll("(.*)"+SEPARATEUR_VALEURS+SEPARATEUR_VALEURS+"(.*)", "$1"+SEPARATEUR_VALEURS+"$2"); |
| chaineExistante = chaineExistante.replaceAll("^"+SEPARATEUR_VALEURS+"(.*)", "$1"); |
| chaineExistante = chaineExistante.replaceAll("(.*)"+SEPARATEUR_VALEURS+"$", "$1"); |
| this.set(champ, chaineExistante); |
| } |
| } |
| } |
| protected void remplacerTypeDansChaineDenormalise(String champ, String type, Object valeur) { |
| if (valeur != null && !valeur.equals("")) { |
| ajouterChaineDenormaliseAvecType(champ, type, valeur); |
| } else { |
| supprimerTypeDansChaineDenormalise(champ, type); |
| } |
| } |
| /** |
| * Ajoute un nouvel élément sans type à une chaine dénormalisée. |
| * Champ de type "truk" contenant seulement des valeurs séparées par ";;". |
| * Si l'élément existe déjà, il ne sera pas ajouté. |
| * |
| * @param champ le nom du champ dénormalisé |
| * @param valeur la valeur à ajouter |
| */ |
| protected void ajouterChaineDenormalise(String champ, Object valeur) { |
| if (valeur instanceof String) { |
| String chaineExistante = renvoyerValeurCorrecte(champ); |
| if (UtilString.isEmpty(chaineExistante)) { |
| this.set(champ, valeur); |
| } else { |
| // Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons |
| if (!chaineExistante.matches("(^|"+SEPARATEUR_VALEURS+")"+valeur+"("+SEPARATEUR_VALEURS+"|$)")) { |
| this.set(champ, chaineExistante+SEPARATEUR_VALEURS+valeur); |
| } |
| } |
| } |
| } |
| /** |
| * Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk"). |
| * |
| * @param champ le nom du champ dénormalisé |
| * @param type le type de la valeur à ajouter |
| * @param valeur la valeur à ajouter |
| */ |
| protected void setChaineDenormaliseUnique(String champ, String type, String valeur) { |
| if (valeur == null || UtilString.isEmpty(valeur)) { |
| this.set(champ, ""); |
| } else if (valeur instanceof String) { |
| if (((String) valeur).matches("^[0-9]+$")) { |
| this.set(champ, valeur); |
| } else { |
| this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur); |
| } |
| } |
| } |
| /** |
| * Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk"). |
| * |
| * @param champ le nom du champ dénormalisé |
| */ |
| protected String getChaineDenormaliseUnique(String champ) { |
| String valeur = renvoyerValeurCorrecte(champ); |
| if (!UtilString.isEmpty(valeur)) { |
| valeur = valeur.replaceFirst("^"+TYPE_AUTRE+SEPARATEUR_TYPE_VALEUR, ""); |
| } |
| return valeur; |
| } |
| protected String getInfoDenormaliseParType(String chaineExistante, String type) { |
| String sortie = ""; |
| if (!UtilString.isEmpty(chaineExistante)) { |
| String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS); |
| for (int i = 0; i < valeurs.length; i++) { |
| if (valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) { |
| sortie = valeurs[i].replaceFirst("^"+type+SEPARATEUR_TYPE_VALEUR, ""); |
| } |
| } |
| } |
| return sortie; |
| } |
| /** |
| * Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur |
| * |
| * @param champ le nom du champ dénormalisé |
| * @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;) |
| */ |
| public Object getChaineDenormaliseAsMapOrList(String champ) { |
| Object retourObjet = null; |
| String valeurChamp = renvoyerValeurCorrecte(champ); |
| if ((valeurChamp!=null)&&(!valeurChamp.trim().equals(""))) { |
| String[] valeurs = valeurChamp.split(SEPARATEUR_VALEURS); |
| if (valeurs.length > 0) { |
| if (valeurs[0].contains(SEPARATEUR_TYPE_VALEUR)) { |
| // Les champs sont typés, on en fait une Map |
| HashMap<String,String> mapValeurs = new HashMap<String,String>(); |
| for (int i = 0; i < valeurs.length; i++) { |
| String typeEtValeur[] = valeurs[i].split(SEPARATEUR_TYPE_VALEUR); |
| mapValeurs.put(typeEtValeur[1], typeEtValeur[0]); |
| } |
| retourObjet = mapValeurs; |
| } |
| else { |
| //Les champs ne sont pas typés, on en fait une Liste |
| LinkedList<String> listeValeurs = new LinkedList<String>(); |
| for (int i = 0; i < valeurs.length; i++) { |
| if ((valeurs[i]!=null)&&(!valeurs[i].equals(""))) { |
| listeValeurs.add(valeurs[i]); |
| } |
| } |
| retourObjet = listeValeurs; |
| } |
| } |
| } |
| return retourObjet; |
| } |
| /** |
| * Permet de modifier correctement une chaine dénormalisée (champ de type "truk"). |
| * Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée. |
| * Si aucun type n'est trouvé, nous en ajoutons un avec la nouvelle valeur. |
| * |
| * @param champ le nom du champ dénormalisé |
| * @param type le type de la valeur à modifier |
| * @param valeur la valeur pour le type en question |
| */ |
| protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) { |
| if (valeur == null || valeur.equals("")) { |
| supprimerTypeDansChaineDenormalise(champ, type); |
| } else if (valeur instanceof String) { |
| String chaineExistante = renvoyerValeurCorrecte(champ); |
| if (UtilString.isEmpty(chaineExistante)) { |
| this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur); |
| } else { |
| String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS); |
| HashMap<String,String> valeursModifiees = new HashMap<String,String>(); |
| for (int i = 0; i < valeurs.length; i++) { |
| if (valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) { |
| valeursModifiees.put(type, type+SEPARATEUR_TYPE_VALEUR+valeur); |
| } else if (i == (valeurs.length -1) && !valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) { |
| valeursModifiees.put(valeurs[i].split(SEPARATEUR_TYPE_VALEUR)[0], valeurs[i]); |
| valeursModifiees.put(type, type+SEPARATEUR_TYPE_VALEUR+valeur); |
| } else { |
| valeursModifiees.put(valeurs[i].split(SEPARATEUR_TYPE_VALEUR)[0], valeurs[i]); |
| } |
| } |
| String[] tableauValeursModifiees = valeursModifiees.values().toArray(new String[valeursModifiees.size()]); |
| this.set(champ, UtilArray.implode(tableauValeursModifiees, SEPARATEUR_VALEURS)); |
| } |
| } |
| } |
| protected String getInfoDenormaliseParPosition(String chaineExistante, int position) { |
| String sortie = ""; |
| if (!UtilString.isEmpty(chaineExistante)) { |
| String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS); |
| if (valeurs.length >= position) { |
| for (int i = 0; i < valeurs.length; i++) { |
| if (i == (position - 1)) { |
| if (valeurs[i].contains(SEPARATEUR_TYPE_VALEUR)) { |
| sortie = valeurs[i].replaceFirst("^[^#]+"+SEPARATEUR_VALEURS, ""); |
| } else { |
| sortie = valeurs[i]; |
| } |
| break; |
| } |
| } |
| } |
| } |
| return sortie; |
| } |
| /** |
| * Permet de modifier correctement une chaine dénormalisée (champ de type "truk"). |
| * Remplace par la valeur l'instance dont la position a été indiquée. |
| * Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée. |
| * Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié. |
| * |
| * @param champ le nom du champ dénormalisé |
| * @param position le type de la valeur à modifier |
| * @param valeur la valeur à remplacer à la position indiquée |
| */ |
| protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) { |
| if (valeur == null || valeur.equals("")) { |
| supprimerChaineDenormaliseParPosition(champ, position); |
| } else if (valeur instanceof String) { |
| String chaineExistante = renvoyerValeurCorrecte(champ); |
| if (UtilString.isEmpty(chaineExistante)) { |
| this.set(champ, valeur); |
| } else { |
| String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS); |
| if (valeurs.length >= position) { |
| for (int i = 0; i < valeurs.length; i++) { |
| if (i == (position - 1)) { |
| valeurs[i] = (String) valeur; |
| break; |
| } |
| } |
| this.set(champ, UtilArray.implode(valeurs, SEPARATEUR_VALEURS)); |
| } |
| } |
| } |
| } |
| protected void supprimerChaineDenormaliseParPosition(String champ, int position) { |
| String chaineExistante = renvoyerValeurCorrecte(champ); |
| if (!UtilString.isEmpty(chaineExistante)) { |
| String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS); |
| HashMap<String,String> valeursModifiees = new HashMap<String,String>(); |
| if (valeurs.length >= position) { |
| for (int i = 0; i < valeurs.length; i++) { |
| if (i != (position - 1)) { |
| valeursModifiees.put(""+i, valeurs[i]); |
| } |
| } |
| String[] tableauValeursModifiees = valeursModifiees.values().toArray(new String[valeursModifiees.size()]); |
| this.set(champ, UtilArray.implode(tableauValeursModifiees, SEPARATEUR_VALEURS)); |
| } |
| } |
| } |
| /** (non-Javadoc) |
| * @see java.lang.Object#toString() |
| */ |
| public String toString() { |
| String sortie = ""; |
| // Champs du BaseModelData |
| Set<String> proprietes = this.getProperties().keySet(); |
| TreeSet<String> proprietesTriees = new TreeSet<String>(proprietes); |
| for (Iterator<String> it = proprietesTriees.iterator(); it.hasNext();) { |
| String cle = it.next(); |
| if (this.get(cle) != null && !this.get(cle).equals("")) { |
| sortie += cle+" : "+this.get(cle).toString()+"\n"; |
| } |
| } |
| return sortie; |
| } |
| public Boolean comparer(BaseModelData objetAComparer) { |
| Boolean retour = true; |
| Map<String, Object> a = this.getProperties(); |
| Map<String, Object> b = objetAComparer.getProperties(); |
| if (a.size() != b.size()) { |
| retour = false; |
| } else { |
| Set<String> cles = a.keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| if (a.get(cle) != null && !a.get(cle).equals(b.get(cle))) { |
| retour = false; |
| break; |
| } |
| } |
| } |
| return retour; |
| } |
| public Object cloner(BaseModelData nouvelleInstance) { |
| Map<String, Object> proprietes = this.getProperties(); |
| Set<String> cles = proprietes.keySet(); |
| for (Iterator<String> it = cles.iterator(); it.hasNext();) { |
| String cle = it.next(); |
| nouvelleInstance.set(cle, this.get(cle)); |
| } |
| return nouvelleInstance; |
| } |
| /** |
| * Renvoie une chaîne de caractère formatée et encodée pour POST avec toutes les propriétés du modèle |
| * */ |
| public String obtenirChainePOST() { |
| String post = ""; |
| FastMap<?> proprietees = (FastMap<?>) getProperties(); |
| Collection<String> cles = proprietees.keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| //Les Radio Box couplées à la fonction autobind créent des variables gxt.RadioGroup.X, qu'il ne faut pas mettre dans la requête |
| if (!cle.startsWith("gxt.")&&!cle.matches("^_.+_$")) { |
| //Si, et seulement si, la valeur diffère de la valeur initiale OU la clé est dans les champs obligatoire |
| if (Arrays.asList(getChampsObligatoires()).contains(getPrefixe() + "_" + cle) || ((valeursInitiales.get(cle) != null && !valeursInitiales.get(cle).equals(get(cle))) || valeursInitiales.get(cle) == null)) { |
| post += getPrefixe() + "_" + cle + "=" + URL.encodeComponent(renvoyerValeurCorrecte(cle)); |
| if (it.hasNext()) { |
| post += "&"; |
| } |
| } |
| } |
| } |
| return post; |
| } |
| /** |
| * Met à jour l'objet this avec les données de l'objet passé en paramêtre. |
| * |
| * */ |
| public void mettreAJour(aDonnee nouveau) { |
| Collection<String> cles = nouveau.getProperties().keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| if (!this.get(cle).equals(nouveau.get(cle))) { |
| this.set(cle, nouveau.get(cle)); |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/aDonnee.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/personne/Personne.java |
|---|
| New file |
| 0,0 → 1,386 |
| package org.tela_botanica.client.modeles.personne; |
| import java.util.Date; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilString; |
| import com.extjs.gxt.ui.client.data.ModelData; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.i18n.client.DateTimeFormat; |
| import com.google.gwt.json.client.JSONObject; |
| public class Personne extends aDonnee { |
| private static final long serialVersionUID = -6974716696155349332L; |
| public static final String PREFIXE = "cp"; |
| public static final String TELEPHONE_FIXE = "FIX"; |
| public static final String TELEPHONE_GSM = "GSM"; |
| public static final String TELEPHONE_FAX = "FAX"; |
| public static final String ETRE_DECEDE = "30745"; |
| public static final String ETRE_VIVANT = "30746"; |
| public static String[] champsObligatoires = {"cp_id_personne"}; |
| private PublicationAPersonneListe publicationsLiees= null; |
| public Personne() { |
| } |
| public Personne(ModelData model) |
| { |
| Map<String, Object> a = model.getProperties(); |
| Set<String> cles = a.keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| if (a.get(cle) != null) { |
| String cleObjet = cle.replaceFirst("^"+getPrefixe()+"_", ""); |
| this.set(cleObjet, a.get(cle)); |
| } |
| } |
| } |
| public Personne(JSONObject personne) { |
| initialiserModele(personne); |
| //Ajout du champ courriel principal |
| this.setCourrielPrinc(this.getInfoDenormaliseParPosition(this.renvoyerValeurCorrecte("truk_courriel"), 1)); |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| public Object obtenirValeurChamp(String nomChamp) { |
| return renvoyerValeurCorrecte(nomChamp); |
| } |
| public Date getDate(String nomChamp) { |
| String strDate = renvoyerValeurCorrecte(nomChamp); |
| Date dateRetour = null; |
| try { |
| if ((strDate != null) && (!strDate.equals("0000-00-00"))) { |
| dateRetour = DateTimeFormat.getFormat("yyyy-MM-dd").parseStrict(strDate); |
| } |
| } catch (StringIndexOutOfBoundsException e) { |
| GWT.log("Impossible de parser la date " + strDate, e); |
| } |
| return dateRetour; |
| } |
| public String getString(String nomChamp) { |
| return String.valueOf(renvoyerValeurCorrecte(nomChamp)); |
| } |
| //Traitement des truks |
| protected void remplacerTypeDansChaineDenormalise(String champ, String type, Object valeur) { |
| if (valeur != null && !valeur.equals("")) { |
| ajouterChaineDenormaliseAvecType(champ, type, valeur); |
| } else { |
| supprimerTypeDansChaineDenormalise(champ, type); |
| } |
| } |
| /** |
| * Ajoute un nouvel élément sans type à une chaine dénormalisée. |
| * Champ de type "truk" contenant seulement des valeurs séparées par ";;". |
| * Si l'élément existe déjà, il ne sera pas ajouté. |
| * |
| * @param champ le nom du champ dénormalisé |
| * @param valeur la valeur à ajouter |
| */ |
| protected void ajouterChaineDenormalise(String champ, Object valeur) { |
| if (valeur instanceof String) { |
| String chaineExistante = renvoyerValeurCorrecte(champ); |
| if (chaineExistante.equals("")) { |
| this.set(champ, valeur); |
| } else { |
| // Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons |
| if (!chaineExistante.matches("(^|"+SEPARATEUR_VALEURS+")"+valeur+"("+SEPARATEUR_VALEURS+"|$)")) { |
| this.set(champ, chaineExistante+SEPARATEUR_VALEURS+valeur); |
| } |
| } |
| } |
| } |
| // ID PERSONNE |
| public String getId() { |
| return renvoyerValeurCorrecte("id_personne"); |
| } |
| public void setId(String personneId) { |
| this.set("id_personne", personneId); |
| } |
| // ID PROJET |
| public String getIdProjet() { |
| return renvoyerValeurCorrecte("ce_projet"); |
| } |
| // NOM COMPLET |
| public String getNomComplet() { |
| return renvoyerValeurCorrecte("fmt_nom_complet"); |
| } |
| public void setNomComplet(String nomComplet) { |
| this.set("fmt_nom_complet", nomComplet); |
| } |
| public void setFmtNomComplet(String prefixe, String suffixe) { |
| String fmtNomComplet = ""; |
| if ((prefixe != null)&&(!prefixe.trim().equals(""))) { |
| fmtNomComplet += prefixe + " "; |
| } |
| if ((this.getPrenom()!=null)&&(!this.getPrenom().trim().equals(""))) { |
| fmtNomComplet += this.getPrenom() + " "; |
| } |
| if ((this.getNom()!=null)&&(!this.getNom().trim().equals(""))) { |
| fmtNomComplet += this.getNom() + " "; |
| } |
| if ((suffixe!=null)&&(!suffixe.trim().equals(""))) { |
| fmtNomComplet += suffixe; |
| } |
| setNomComplet(UtilString.ucFirst(fmtNomComplet)); |
| } |
| // NOM |
| public String getNom() { |
| return renvoyerValeurCorrecte("nom"); |
| } |
| public void setNom(String nom) { |
| set("nom", nom); |
| } |
| // PRÉNOM |
| public String getPrenom() { |
| return renvoyerValeurCorrecte("prenom"); |
| } |
| public void setPrenom(String prenom) { |
| set("prenom", prenom); |
| } |
| // TÉLÉPHONE |
| public String getTelephone() { |
| return renvoyerValeurCorrecte("truk_telephone"); |
| } |
| public void setTelephone(String t) { |
| this.set("truk_telephone", t); |
| } |
| public void ajouterTelephone(String type, Object valeur) { |
| ajouterChaineDenormaliseAvecType("truk_telephone", type, valeur); |
| } |
| public String selectionnerTelephone(String type) { |
| return getInfoDenormaliseParType(renvoyerValeurCorrecte("truk_telephone"), type); |
| } |
| // FAX |
| public String getFax() { |
| return renvoyerValeurCorrecte("truk_fax"); |
| } |
| public void setFax(String f) { |
| this.set("truk_fax", f); |
| } |
| public void ajouterFax(Object valeur) { |
| ajouterChaineDenormalise("truk_fax", valeur); |
| } |
| public String selectionnerFax(int position) { |
| return getInfoDenormaliseParPosition(renvoyerValeurCorrecte("truk_fax"), position); |
| } |
| // COURRIEL |
| public String getCourriel() { |
| return renvoyerValeurCorrecte("truk_courriel"); |
| } |
| public void setCourriel(String c) { |
| this.set("truk_courriel", c); |
| } |
| public void ajouterCourriel(String c) { |
| ajouterChaineDenormalise("truk_courriel", c); |
| } |
| public String selectionnerCourriel(int position) { |
| return getInfoDenormaliseParPosition(renvoyerValeurCorrecte("truk_courriel"), position); |
| } |
| // SPÉCIALITÉ |
| public String getSpecialite() { |
| return renvoyerValeurCorrecte("ce_truk_specialite"); |
| } |
| public void setSpecialite(String s) { |
| // Pas de liste pour l'instant, donc tout passe dans "Autre". |
| setChaineDenormaliseUnique("ce_truk_specialite", "AUTRE", s); |
| } |
| public String afficherSpecialite() { |
| return getChaineDenormaliseUnique("ce_truk_specialite"); |
| } |
| // NAISSANCE DATE |
| public String getNaissanceDate() { |
| String dateNaiss = ""; |
| dateNaiss = get("naissance_date"); |
| if (UtilString.isEmpty(dateNaiss)||dateNaiss.equals("0000-00-00")) { |
| dateNaiss = Mediateur.i18nC.inconnue(); |
| } |
| 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"); |
| return getDateSouple(valeurDateNaissance); |
| } |
| public void setNaissanceDate(Date naissanceDate) { |
| if (naissanceDate != null) { |
| this.set("naissance_date", DateTimeFormat.getFormat("yyyy-MM-dd").format(naissanceDate)); |
| } else { |
| this.set("naissance_date", null); |
| } |
| } |
| // NAISSANCE LIEU |
| public String getNaissanceLieu() { |
| return renvoyerValeurCorrecte("naissance_lieu"); |
| } |
| public void setNaissanceLieu(String naissanceLieu) { |
| this.set("naissance_lieu", naissanceLieu); |
| } |
| // DÉCÉS |
| public boolean estDecedee() { |
| String ceDeces = getDeces(); |
| if (ceDeces.isEmpty() || ceDeces.equals(ETRE_DECEDE)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| public String getDeces() { |
| return renvoyerValeurCorrecte("ce_deces"); |
| } |
| public String getAnneeOuDateDeces() { |
| String valeurDateDeces = get("deces_date"); |
| return getDateSouple(valeurDateDeces); |
| } |
| public void setDeces(String deces) { |
| set("ce_deces", deces); |
| } |
| public void setDeces(Date decesDate, String lieuDeces) { |
| set("ce_deces", ETRE_DECEDE); |
| setDecesDate(decesDate); |
| setDecesLieu(lieuDeces); |
| } |
| public void setNonDecedee() { |
| set("ce_deces", ETRE_VIVANT); |
| setDecesDate(null); |
| setDecesLieu(""); |
| } |
| // DÉCÉS DATE |
| public String getDecesDate() { |
| String dateDeces = renvoyerValeurCorrecte("deces_date"); |
| if (UtilString.isEmpty(dateDeces) || dateDeces.equals("0000-00-00")) { |
| dateDeces = Mediateur.i18nC.inconnue(); |
| } |
| return dateDeces; |
| } |
| public void setDecesDate(Date decesDate) { |
| if (decesDate != null) { |
| this.set("deces_date", DateTimeFormat.getFormat("yyyy-MM-dd").format(decesDate)); |
| } else { |
| this.set("deces_date", ""); |
| } |
| } |
| // DÉCÉS LIEU |
| public String getDecesLieu() { |
| return renvoyerValeurCorrecte("deces_lieu"); |
| } |
| public void setDecesLieu(String decesLieu) { |
| this.set("deces_lieu", decesLieu); |
| } |
| // PARAMÊTRE |
| public String getParametre() { |
| return renvoyerValeurCorrecte("parametre"); |
| } |
| public void setParametre(String parametre) { |
| this.set("parametre", parametre); |
| } |
| public void setCourrielPrinc(String courriel) { |
| this.set("_courriel_princ_", courriel); |
| } |
| public String getCourrielPrinc() { |
| return (String) this.get("_courriel_princ_"); |
| } |
| // PUBLICATIONS LIÉES |
| public PublicationAPersonneListe getPublicationsLiees() { |
| return publicationsLiees; |
| } |
| public void setPublicationsLiees(PublicationAPersonneListe relationsCollectionAPublication) { |
| publicationsLiees = relationsCollectionAPublication; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/personne/Personne.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/personne/PersonneListe.java |
|---|
| New file |
| 0,0 → 1,137 |
| package org.tela_botanica.client.modeles.personne; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.i18n.client.Dictionary; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Classe contenant les informations sur les Personnes renvoyées par un objet de type DAO. |
| * |
| * @author Grégoire DUCHÉ |
| * |
| */ |
| public class PersonneListe extends aDonneeListe<Personne> implements ListePaginable { |
| private static final long serialVersionUID = 2930530504922300155L; |
| private int currentPage = 0; |
| private int nbElementsPage = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); |
| private int nbElementsTotal; |
| private Rafraichissable vueARafraichir; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public PersonneListe() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param taille la taille de la table de hachage |
| */ |
| public PersonneListe(int taille) { |
| super(taille); |
| } |
| /** |
| * Constructeur pour une liste de personne |
| * |
| * @param dates |
| */ |
| public PersonneListe(JSONArray ListeDePersonnes) { |
| super(ListeDePersonnes.size()); |
| initialiserPersonneListe(ListeDePersonnes); |
| } |
| public PersonneListe(JSONArray ListeDePersonnes, JSONNumber nbElements, Rafraichissable vueARafraichir) { |
| super(ListeDePersonnes.size()); |
| this.nbElementsTotal = Integer.valueOf(nbElements.toString()); |
| this.vueARafraichir = vueARafraichir; |
| initialiserPersonneListe(ListeDePersonnes); |
| } |
| private void initialiserPersonneListe(JSONArray ListeDePersonnes) { |
| final int taillemax = ListeDePersonnes.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject personneCourante = ListeDePersonnes.get(i).isObject(); |
| if (personneCourante != null) { |
| Personne personne = new Personne(personneCourante); |
| this.put(personne.getId(), personne); |
| } |
| } |
| } |
| public int[] getPageTable() { |
| int[] page = new int[4]; |
| // nombre de pages au total |
| page[0] = calculerNbPages(); |
| // Page En Cours |
| page[1] = currentPage; |
| // nbElementsParPage |
| page[2] = nbElementsPage; |
| // et le dernier le nombre total d'éléments |
| page[3] = nbElementsTotal; |
| return page; |
| } |
| /** |
| * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements |
| * donnés en fonction de la taille de page en cours |
| * |
| * @return le nombre de pages |
| */ |
| public int calculerNbPages() { |
| // À cause de la bétise de java pour les conversion implicite, on fait quelques conversions manuellement |
| // pour eviter qu'il arrondisse mal la division nombre de pages = (nombre d'element / taille de la page) |
| // arrondie à l'entier supérieur. |
| double nPage = (1.0 * nbElementsTotal) / (1.0 * nbElementsPage); |
| double nPageRound = Math.ceil(nPage); |
| Double nPageInt = new Double(nPageRound); |
| // Convertion en entier |
| return nPageInt.intValue(); |
| } |
| public void changerNumeroPage(int pageCourante) { |
| currentPage = pageCourante; |
| selectionnerPersonne(); |
| } |
| public void changerTaillePage(int nouvelleTaillePage) { |
| nbElementsPage = nouvelleTaillePage; |
| selectionnerPersonne(); |
| } |
| public void recharger() { |
| selectionnerPersonne(); |
| } |
| public void setPageCourante(int pageCourante) { |
| this.currentPage = pageCourante; |
| } |
| public void setTaillePage(int taillePage) { |
| this.nbElementsPage = taillePage; |
| } |
| public void selectionnerPersonne() { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerPersonne(vueARafraichir, null, mediateur.getProjetId(), currentPage, nbElementsPage, null); |
| } |
| public void filtrerParNom(String nom) { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| Personne personne = new Personne(); |
| personne.setNom("%" + nom + "%"); |
| mediateur.selectionnerPersonne(vueARafraichir, personne, mediateur.getProjetId(), currentPage, nbElementsPage, null); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/personne/PersonneListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/personne/PersonneAsyncDao.java |
|---|
| New file |
| 0,0 → 1,187 |
| package org.tela_botanica.client.modeles.personne; |
| import java.util.HashMap; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.synchronisation.Sequenceur; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| 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 { |
| private static final String SERVICE_NOM = "CoelPersonne"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public PersonneAsyncDao(Rafraichissable vue) { |
| if (Mediateur.DEBUG) System.out.println("|| PersonneAsyncDao > vueARafraichir = "+vue.getClass().toString()); |
| 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) { |
| String nom = (nomComplet == null) ? "%" : nomComplet+"%"; |
| String[] parametres = {personneId, projetId, nom}; |
| HashMap<String, String> restrictions = new HashMap<String, String>(); |
| if (nbElements != -1) { |
| restrictions.put("limit", String.valueOf(nbElements)); |
| } |
| /** 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 **/ |
| if (seqId != null) { |
| if (Mediateur.DEBUG) System.out.println("<-- PersonneAsyncDao > Liste paginée, retour au sequenceur"); |
| Reponse reponseRequete = new Reponse(responseValue, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| if (Mediateur.DEBUG) System.out.println("<-- PersonneAsyncDao > Liste paginée, retour à "+vueARafraichir.getClass().toString()); |
| 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 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) { |
| if (Mediateur.DEBUG) System.out.println("<-- PersonneAsyncDao > Liste non paginée, retour au sequenceur"); |
| Reponse reponseRequete = new Reponse(info, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| if (Mediateur.DEBUG) System.out.println("<-- PersonneAsyncDao > Liste non paginée, retour à "+vueARafraichir.getClass().toString()); |
| 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) { |
| String postDonneesEncodees = personne.obtenirChainePOST(); |
| postDonneesEncodees += "&cmhl_ce_modifier_par=" + utilisateurId; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("ajout_personne"); |
| String structureIdOuMessage = responseValue.isString().stringValue(); |
| if (structureIdOuMessage.matches("^[0-9]+$")) { |
| info.setDonnee(structureIdOuMessage); |
| } else { |
| info.setMessage(structureIdOuMessage); |
| } |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void modifier(Personne personne) { |
| String postDonneesEncodees = personne.obtenirChainePOST(); |
| postDonneesEncodees += "&cmhl_ce_modifier_par=" + utilisateurId; |
| GWT.log(postDonneesEncodees, null); |
| String[] parametres = {personne.getId()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| Information info = new Information("modification_personne"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void supprimer(String personnesId) { |
| String[] parametres = {utilisateurId, personnesId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("suppression_personne"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/personne/PersonneAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/Utilisateur.java |
|---|
| New file |
| 0,0 → 1,183 |
| package org.tela_botanica.client.modeles; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Set; |
| import com.google.gwt.json.client.JSONObject; |
| public class Utilisateur extends aDonnee { |
| private static final long serialVersionUID = -4016615552202089985L; |
| public static final String PREFIXE = "cp"; |
| public static String[] champsObligatoires = {"cp_id_personne"}; |
| public Utilisateur() { |
| initialiserUtilisateur(null, false); |
| } |
| public Utilisateur(String id, boolean identifie) { |
| initialiserUtilisateur(id, identifie); |
| } |
| public Utilisateur(JSONObject utilisateur) { |
| // l'objet JSON est une table de hachage |
| Set<String> im = utilisateur.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| // Valeur est vide par défaut |
| String valeur = ""; |
| if (utilisateur.get(cle).isString() != null) { |
| valeur = utilisateur.get(cle).isString().stringValue(); |
| this.set(cleObjet, valeur); |
| } else { |
| this.set(cleObjet, valeur); |
| } |
| } |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| private void initialiserUtilisateur(String id, boolean etreIdentifie) { |
| setId(id); |
| setIdentification(etreIdentifie); |
| } |
| // ID |
| /** |
| * Retourne l'id de l'utilisateur ou l'identifiant de session si la personne n'est pas identifiée. |
| * @return String id de l'utilisateur |
| */ |
| public String getId() { |
| return renvoyerValeurCorrecte("id_personne"); |
| } |
| public void setId(String id) { |
| set("id_personne", id); |
| } |
| // NOM COMPLET |
| /** |
| * Retourne le nom complet et formaté de l'utilisateur |
| * @return String nom complet |
| */ |
| public String getNomComplet() { |
| return renvoyerValeurCorrecte("fmt_nom_complet"); |
| } |
| public void setNomComplet(String nom_complet) { |
| set("fmt_nom_complet", nom_complet); |
| } |
| // PRÉNOM |
| /** |
| * Retourne le prénom de l'utilisateur |
| * @return String prénom |
| */ |
| public String getPrenom() { |
| return renvoyerValeurCorrecte("prenom"); |
| } |
| public void setPrenom(String prenom) { |
| set("prenom", prenom); |
| } |
| // NOM |
| /** |
| * Retourne le nom de l'utilisateur |
| * @return String nom |
| */ |
| public String getNom() { |
| return renvoyerValeurCorrecte("nom"); |
| } |
| public void setNom(String nom) { |
| set("nom", nom); |
| } |
| // LOGIN |
| /** |
| * Retourne le login de l'utilisateur ou l'identifiant de session si la personne n'est pas identifiée. |
| * @return String login |
| */ |
| public String getLogin() { |
| return renvoyerValeurCorrecte("login"); |
| } |
| public void setLogin(String l) { |
| set("login", l); |
| } |
| // MOT DE PASSE |
| /** |
| * Retourne le mot de passe de l'utilisateur |
| * @return String mot de passe |
| */ |
| public String getMotDePasse() { |
| return renvoyerValeurCorrecte("mot_de_passe"); |
| } |
| public void setMotDePasse(String mdp) { |
| set("mot_de_passe", mdp); |
| } |
| // PARAMÈTRE |
| public String getParametre() { |
| String xml = renvoyerValeurCorrecte("parametre"); |
| if (xml.equals("")) { |
| xml = "<?xml version='1.0' encoding='UTF-8'?>\n<parametres>\n</parametres>"; |
| } |
| return xml; |
| } |
| public void setParametre(String param) { |
| set("parametre", param); |
| } |
| // +---------------------------------------------------------------------------------------------------------------+ |
| // IDENTIFIÉ |
| /** |
| * Retourne vrai si utilisateur est identifié. |
| * @return boolean |
| */ |
| public boolean isIdentifie() { |
| if (get("identifie").equals(true)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| 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); |
| } |
| public String getLicence() { |
| if (this.get("licenceAcceptee") != null) { |
| return this.get("licenceAcceptee"); |
| } else { |
| return ""; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/Utilisateur.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/aDonneeListe.java |
|---|
| New file |
| 0,0 → 1,28 |
| package org.tela_botanica.client.modeles; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| abstract public class aDonneeListe<T> extends HashMap<String,T> { |
| private static final long serialVersionUID = -8567158151109232877L; |
| public aDonneeListe() { |
| super(); |
| } |
| public aDonneeListe(int taille) { |
| super(taille); |
| } |
| public List<T> toList() { |
| List<T> listeACreer = new ArrayList<T>(); |
| Iterator<String> it = keySet().iterator(); |
| while (it.hasNext()) { |
| listeACreer.add((T) get(it.next())); |
| } |
| return listeACreer; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/aDonneeListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/Collection.java |
|---|
| New file |
| 0,0 → 1,450 |
| package org.tela_botanica.client.modeles.collection; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| 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 { |
| private static final long serialVersionUID = 3295310312337145716L; |
| public static final String PREFIXE = "cc"; |
| private CollectionBotanique botanique = null; |
| private CollectionAPersonneListe personnesLiees = null; |
| private CollectionAPublicationListe publicationsLiees = null; |
| private CollectionACommentaireListe commentairesLiees = null; |
| public static String[] champsObligatoires = {"cc_id_collection","cc_ce_type"}; |
| public Collection() { |
| } |
| public Collection(ModelData model) |
| { |
| Map<String, Object> a = model.getProperties(); |
| Set<String> cles = a.keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| if (a.get(cle) != null) { |
| String cleObjet = cle.replaceFirst("^"+getPrefixe()+"_", ""); |
| this.set(cleObjet, a.get(cle)); |
| } |
| } |
| } |
| public Collection(JSONObject collection){ |
| initialiserModele(collection); |
| } |
| @Override |
| protected String getPrefixe(){ |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| // BOTANIQUE |
| public CollectionBotanique getBotanique() { |
| if (botanique == null) { |
| botanique = new CollectionBotanique(); |
| } |
| return botanique; |
| } |
| public void setBotanique(CollectionBotanique botaniqueAStocker) { |
| botanique = botaniqueAStocker; |
| } |
| // PERSONNES LIÉES |
| public CollectionAPersonneListe getPersonnesLiees() { |
| if (personnesLiees == null) { |
| personnesLiees = new CollectionAPersonneListe(); |
| } |
| return personnesLiees; |
| } |
| public void setPersonnesLiees(CollectionAPersonneListe relationsCollectionAPersonne) { |
| personnesLiees = relationsCollectionAPersonne; |
| } |
| // PUBLICATIONS LIÉES |
| public CollectionAPublicationListe getPublicationsLiees() { |
| if (publicationsLiees == null) { |
| publicationsLiees = new CollectionAPublicationListe(); |
| } |
| return publicationsLiees; |
| } |
| public void setPublicationsLiees(CollectionAPublicationListe relationsCollectionAPublication) { |
| publicationsLiees = relationsCollectionAPublication; |
| } |
| // COMMENTAIRES LIÉS |
| public CollectionACommentaireListe getCommentairesLiees() { |
| if (commentairesLiees == null) { |
| commentairesLiees = new CollectionACommentaireListe(); |
| } |
| return commentairesLiees; |
| } |
| public void setCommentairesLiees(CollectionACommentaireListe relationsCollectionACommentaire) { |
| commentairesLiees = relationsCollectionACommentaire; |
| } |
| // ID |
| public String getId() { |
| return renvoyerValeurCorrecte("id_collection"); |
| } |
| public void setId(String idCollection) { |
| this.set("id_collection", idCollection); |
| } |
| // CE PROJET |
| public String getIdProjet() { |
| return renvoyerValeurCorrecte("ce_projet"); |
| } |
| public void setIdProjet(String idProjet) { |
| this.set("ce_projet", idProjet); |
| } |
| // COLLECTION MERE ID |
| public String getCollectionMereId() { |
| return renvoyerValeurCorrecte("ce_mere"); |
| } |
| public void setCollectionMereId(String collectionMereId) { |
| this.set("ce_mere", collectionMereId); |
| } |
| // COLLECTION MERE NOM |
| public String getCollectionMereNom() { |
| return renvoyerValeurCorrecte("_collection_mere_nom_"); |
| } |
| public void setCollectionMereNom(String collectionMereNom) { |
| this.set("_collection_mere_nom_", collectionMereNom); |
| } |
| // CE STRUCTURE |
| public String getIdStructure() { |
| return renvoyerValeurCorrecte("ce_structure"); |
| } |
| public void setIdStructure(String idStructure) { |
| this.set("ce_structure", idStructure); |
| } |
| // GUID |
| public String getGuid() { |
| return renvoyerValeurCorrecte("guid"); |
| } |
| public void setGuid(String guid) { |
| this.set("guid", guid); |
| } |
| // IDENTIFIANT ALTERNATIF |
| public String getIdAlternatif() { |
| return renvoyerValeurCorrecte("truk_identifiant_alternatif"); |
| } |
| public void setIdAlternatif(String idAlter) { |
| this.set("truk_identifiant_alternatif", idAlter); |
| } |
| // CODE |
| public String getCode() { |
| return renvoyerValeurCorrecte("truk_code"); |
| } |
| public void setCode(String code) { |
| this.set("truk_code", code); |
| } |
| // NOM |
| public String getNom() { |
| return renvoyerValeurCorrecte("nom"); |
| } |
| public void setNom(String nom) { |
| this.set("nom", nom); |
| } |
| // NOM ALTERNATIF |
| public String getNomAlternatif() { |
| return renvoyerValeurCorrecte("truk_nom_alternatif"); |
| } |
| public void setNomAlternatif(String nomAlter) { |
| this.set("truk_nom_alternatif", nomAlter); |
| } |
| // DESCRIPTION |
| public String getDescription() { |
| return renvoyerValeurCorrecte("description"); |
| } |
| public void setDescription(String description) { |
| this.set("description", description); |
| } |
| // DESCRIPTION SPECIALISTE |
| public String getDescriptionSpecialiste() { |
| return renvoyerValeurCorrecte("description_specialiste"); |
| } |
| public void setDescriptionSpecialiste(String descriptionSepcialiste) { |
| this.set("description_specialiste", descriptionSepcialiste); |
| } |
| // HISTORIQUE |
| public String getHistorique() { |
| return renvoyerValeurCorrecte("historique"); |
| } |
| public void setHistorique(String historique) { |
| this.set("historique", historique); |
| } |
| // URL |
| public String getUrls() { |
| return renvoyerValeurCorrecte("truk_url"); |
| } |
| public void setUrls(String urls) { |
| this.set("truk_url", urls); |
| } |
| // GROUPEMENT PRINCIPE |
| public String getGroupementPrincipe() { |
| return renvoyerValeurCorrecte("truk_groupement_principe"); |
| } |
| public void setGroupementPrincipe(String groupementPrincipe) { |
| this.set("truk_groupement_principe", groupementPrincipe); |
| } |
| // GROUPEMENT BUT |
| public String getGroupementBut() { |
| return renvoyerValeurCorrecte("truk_groupement_but"); |
| } |
| public void setGroupementBut(String groupementBut) { |
| this.set("truk_groupement_but", groupementBut); |
| } |
| // TYPE NCD |
| public String getTypeNcd() { |
| return renvoyerValeurCorrecte("ce_type"); |
| } |
| public void setTypeNcd(String typeNcd) { |
| this.set("ce_type", typeNcd); |
| } |
| // TYPE DEPOT |
| public String getTypeDepot() { |
| return renvoyerValeurCorrecte("ce_type_depot"); |
| } |
| public void setTypeDepot(String typeDepot) { |
| this.set("ce_type_depot", typeDepot); |
| } |
| // COTE |
| public String getCote() { |
| return renvoyerValeurCorrecte("cote"); |
| } |
| public void setCote(String cote) { |
| this.set("cote", cote); |
| } |
| // DIMENSSION |
| public String getDimenssion() { |
| return renvoyerValeurCorrecte("dimenssion"); |
| } |
| public void setDimenssion(String dimenssion) { |
| this.set("dimenssion", dimenssion); |
| } |
| // CONDITION ACCÉS |
| public String getConditionAcces() { |
| return renvoyerValeurCorrecte("condition_acces"); |
| } |
| public void setConditionAcces(String conditionAcces) { |
| this.set("condition_acces", conditionAcces); |
| } |
| // CONDITION USAGE |
| public String getConditionUsage() { |
| return renvoyerValeurCorrecte("condition_usage"); |
| } |
| public void setConditionUsage(String conditionUsage) { |
| this.set("condition_usage", conditionUsage); |
| } |
| // COUVERTURE VERNACULAIRE |
| public String getCouvertureVernaculaire() { |
| return renvoyerValeurCorrecte("truk_couverture_vernaculaire"); |
| } |
| public void setCouvertureVernaculaire(String couvertureVernaculaire) { |
| this.set("truk_couverture_vernaculaire", couvertureVernaculaire); |
| } |
| // COUVERTURE TAXONOMIQUE |
| public String getCouvertureTaxonomique() { |
| return renvoyerValeurCorrecte("truk_couverture_taxonomique"); |
| } |
| public void setCouvertureTaxonomique(String couvertureTaxonomique) { |
| this.set("truk_couverture_taxonomique", couvertureTaxonomique); |
| } |
| // COUVERTURE REGNE |
| public String getCouvertureRegne() { |
| return renvoyerValeurCorrecte("truk_couverture_regne"); |
| } |
| public void setCouvertureRegne(String couvertureRegne) { |
| this.set("truk_couverture_regne", couvertureRegne); |
| } |
| // COUVERTURE TEMPORELLE |
| public String getCouvertureTemporelle() { |
| return renvoyerValeurCorrecte("truk_couverture_temporelle"); |
| } |
| public void setCouvertureTemporelle(String couvertureTemporelle) { |
| this.set("truk_couverture_temporelle", couvertureTemporelle); |
| } |
| // COUVERTURE VIE |
| public String getCouvertureVie() { |
| return renvoyerValeurCorrecte("truk_couverture_vie"); |
| } |
| public void setCouvertureVie(String couvertureVie) { |
| this.set("truk_couverture_Vie", couvertureVie); |
| } |
| // CONSERVATION STATUT |
| public String getConservationStatut() { |
| return renvoyerValeurCorrecte("truk_conservation_statut"); |
| } |
| public void setConservationStatut(String conservationStatut) { |
| this.set("truk_conservation_statut", conservationStatut); |
| } |
| // PRESERVATION |
| public String getPreservation() { |
| return renvoyerValeurCorrecte("truk_preservation"); |
| } |
| public void setPreservation(String preservation) { |
| this.set("truk_preservation", preservation); |
| } |
| // DEVELOPPEMENT |
| public String getDeveloppement() { |
| return renvoyerValeurCorrecte("ce_developpement"); |
| } |
| public void setDeveloppement(String developpement) { |
| this.set("ce_developpement", developpement); |
| } |
| // PERIODE CONSTITUTION |
| public String getPeriodeConstitution() { |
| return renvoyerValeurCorrecte("truk_periode_constitution"); |
| } |
| public void setPeriodeConstitution(String periodeConstitution) { |
| if (periodeConstitution.equals(new String(""))) |
| this.set("truk_periode_constitution", null); |
| else |
| this.set("truk_periode_constitution", periodeConstitution); |
| } |
| // COUVERTURE LIEU |
| public String getCouvertureLieu() { |
| return renvoyerValeurCorrecte("truk_couverture_lieu"); |
| } |
| public void setCouvertureLieu(String couvertureLieu) { |
| this.set("truk_couverture_lieu", couvertureLieu); |
| } |
| // COORDONNÉE |
| public String getCoordonnee() { |
| return renvoyerValeurCorrecte("truk_coordonnee"); |
| } |
| public void setCoordonnee(String coordonnee) { |
| this.set("truk_coordonnee", coordonnee); |
| } |
| // SPECIMEN TYPE |
| public String getSpecimenType() { |
| return renvoyerValeurCorrecte("ce_specimen_type"); |
| } |
| public void setSpecimenType(String specimenType) { |
| this.set("ce_specimen_type", specimenType); |
| } |
| // SPECIMEN TYPE NOMBRE |
| public String getSpecimenTypeNbre() { |
| return renvoyerValeurCorrecte("specimen_type_nbre"); |
| } |
| public void setSpecimenTypeNbre(String specimenTypeNbre) { |
| this.set("specimen_type_nbre", specimenTypeNbre); |
| } |
| // SPECIMEN TYPE NOMBRE PRECISION |
| public String getSpecimenTypeNbrePrecision() { |
| return renvoyerValeurCorrecte("ce_specimen_type_nbre_precision"); |
| } |
| public void setSpecimenTypeNbrePrecision(String specimenTypeNbrePrecision) { |
| this.set("ce_specimen_type_nbre_precision", specimenTypeNbrePrecision); |
| } |
| // SPECIMEN TYPE CLASSEMENT |
| public String getSpecimenTypeClassement() { |
| return renvoyerValeurCorrecte("ce_specimen_type_classement"); |
| } |
| public void setSpecimenTypeClassement(String specimenTypeClassement) { |
| this.set("ce_specimen_type_classement", specimenTypeClassement); |
| } |
| // EXPEDITION NOM |
| public String getExpeditionNom() { |
| return renvoyerValeurCorrecte("expedition_nom"); |
| } |
| public void setExpeditionNom(String expeditionNom) { |
| this.set("expedition_nom", expeditionNom); |
| } |
| // DIGITAL MEDIUM |
| public String getDigitalMedium() { |
| return renvoyerValeurCorrecte("truk_digital_medium"); |
| } |
| public void setDigitalMedium(String digitalMedium) { |
| this.set("truk_digital_medium", digitalMedium); |
| } |
| // DIGITAL FORMAT |
| public String getDigitalFormat() { |
| return renvoyerValeurCorrecte("truk_digital_format"); |
| } |
| public void setDigitalFormat(String digitalFormat) { |
| this.set("truk_digital_format", digitalFormat); |
| } |
| // PUBLIC |
| public boolean etrePublic() { |
| String publicMark = getPublic(); |
| boolean estPublic = true; |
| if (publicMark.equals("0")) { |
| estPublic = false; |
| } |
| return estPublic; |
| } |
| public String getPublic() { |
| return renvoyerValeurCorrecte("mark_public"); |
| } |
| public void setBoolPublic(String publicBool) { |
| this.set("mark_public", publicBool); |
| } |
| // +--------------------------------------------------------------------------------------------------------------+ |
| // STRUCTURE NOM |
| public String getStructureNom() { |
| return renvoyerValeurCorrecte("_structure_nom_"); |
| } |
| // STRUCTURE VILLE |
| public String getStructureVille() { |
| return renvoyerValeurCorrecte("_structure_ville_"); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/Collection.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionListe.java |
|---|
| New file |
| 0,0 → 1,124 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.i18n.client.Dictionary; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Classe contenant les informations sur les Collections renvoyées par un objet de type DAO. |
| * |
| * @author Jean-Pascal MILCENT |
| * |
| */ |
| public class CollectionListe extends aDonneeListe<Collection> implements ListePaginable { |
| private static final long serialVersionUID = 8024454926649039456L; |
| private int currentPage = 0; |
| private int nbElementsPage = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); |
| private int nbElementsTotal; |
| private Rafraichissable vueARafraichir; |
| public CollectionListe() { |
| super(); |
| } |
| public CollectionListe(int taille) { |
| super(taille); |
| } |
| public CollectionListe(JSONArray ListeDeCollections) { |
| super(ListeDeCollections.size()); |
| initialiserCollectionListe(ListeDeCollections); |
| } |
| public CollectionListe(JSONArray ListeDeCollections, JSONNumber nbElements, Rafraichissable vueARafraichir) { |
| super(ListeDeCollections.size()); |
| this.nbElementsTotal = Integer.valueOf(nbElements.toString()); |
| this.vueARafraichir = vueARafraichir; |
| initialiserCollectionListe(ListeDeCollections); |
| } |
| private void initialiserCollectionListe(JSONArray ListeDeCollections) { |
| final int taillemax = ListeDeCollections.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject collectionCourante = ListeDeCollections.get(i).isObject() ; |
| if (collectionCourante != null) { |
| Collection collection = new Collection(collectionCourante); |
| CollectionBotanique botanique = new CollectionBotanique(collectionCourante); |
| collection.setBotanique(botanique); |
| this.put(collection.getId(), collection); |
| } |
| } |
| } |
| public void changerNumeroPage(int pageCourante) { |
| currentPage = pageCourante; |
| selectionnerCollection(); |
| } |
| public void changerTaillePage(int nouvelleTaillePage) { |
| nbElementsPage = nouvelleTaillePage; |
| selectionnerCollection(); |
| } |
| public void recharger() { |
| selectionnerCollection(); |
| } |
| public void setPageCourante(int pageCourante) { |
| this.currentPage = pageCourante; |
| } |
| public void setTaillePage(int taillePage) { |
| this.nbElementsPage = taillePage; |
| } |
| public int[] getPageTable() { |
| int[] page = new int[4]; |
| // Nombre de pages au total |
| page[0] = calculerNbPages(); |
| // Page En Cours |
| page[1] = currentPage; |
| // nbElementsParPage |
| page[2] = nbElementsPage; |
| // et le dernier le nombre total d'éléments |
| page[3] = nbElementsTotal; |
| return page; |
| } |
| /** |
| * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements |
| * donnés en fonction de la taille de page en cours |
| * |
| * @return le nombre de pages |
| */ |
| public int calculerNbPages() { |
| // À cause de la bétise de java pour les conversion implicite, on fait quelques conversions manuellement |
| // pour eviter qu'il arrondisse mal la division nombre de pages = (nombre d'element / taille de la page) |
| // arrondie à l'entier supérieur. |
| double nPage = (1.0 * nbElementsTotal) / (1.0 * nbElementsPage); |
| double nPageRound = Math.ceil(nPage); |
| Double nPageInt = new Double(nPageRound); |
| // Convertion en entier |
| return nPageInt.intValue(); |
| } |
| public void selectionnerCollection() { |
| Mediateur mediateur =(Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerCollection(vueARafraichir, null, null, currentPage, nbElementsPage, null); |
| } |
| public void filtrerParNom(String nom) { |
| Mediateur mediateur =(Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerCollection(vueARafraichir, null, "%" + nom + "%", 0, nbElementsPage, null); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionAsyncDao.java |
|---|
| New file |
| 0,0 → 1,294 |
| package org.tela_botanica.client.modeles.collection; |
| import java.util.HashMap; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.projet.ProjetListe; |
| import org.tela_botanica.client.synchronisation.Reponse; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONValue; |
| public class CollectionAsyncDao { |
| public static final String SERVICE_NOM = "CoelCollection"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public CollectionAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| CollectionAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante; |
| 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, final String projetId, final String collectionId, final String nomCollection, final int start, final int nbElements, final Integer seqId) { |
| // Ajout des paramètres et données à selectionner dans l'URL |
| String nom = (nomCollection == null) ? "%" : nomCollection+"%"; |
| String[] parametres = {projetId, collectionId, nom}; |
| HashMap<String, String> restrictions = new HashMap<String, String>(); |
| if (nbElements != -1) { |
| restrictions.put("limit", String.valueOf(nbElements)); |
| } |
| /** 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 **/ |
| if (seqId != null) { |
| if (Mediateur.DEBUG) System.out.println("<-- CollectionAsyncDao > Liste paginée, retour au sequenceur"); |
| Reponse reponseRequete = new Reponse(responseValue, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| if (Mediateur.DEBUG) System.out.println("<-- CollectionAsyncDao > Liste paginée, retour à "+vueARafraichir.getClass().toString()); |
| 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); |
| // et on met à jour le demandeur des données |
| if (seqId != null) { |
| if (Mediateur.DEBUG) System.out.println("<-- CollectionAsyncDao > Liste non paginée, retour au sequenceur"); |
| Reponse reponseRequete = new Reponse(info, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| if (Mediateur.DEBUG) System.out.println("<-- CollectionAsyncDao > Liste non paginée, retour au sequenceur"); |
| 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 { |
| // 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) { |
| String postDonneesEncodees = construirePost(null, collection); |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("ajout_collection"); |
| String structureIdOuMessage = responseValue.isString().stringValue(); |
| if (structureIdOuMessage.matches("^[0-9]+$")) { |
| info.setDonnee(structureIdOuMessage); |
| } else { |
| info.setMessage(structureIdOuMessage); |
| } |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void modifier(Collection collection) { |
| String postDonneesEncodees = construirePost(collection.getId(), collection); |
| String[] parametres = {collection.getId()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| Information info = new Information("modif_collection"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void supprimer(String collectionsId) { |
| String[] parametres = {utilisateurId, collectionsId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("suppression_collection"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| private String construirePost(String collectionId, Collection collection) { |
| String postDonnees = "cmhl_ce_modifier_par=" + URL.encodeComponent(utilisateurId); |
| if (collection != null) { |
| if (collectionId != null) { |
| postDonnees += "&cc_id_collection=" + URL.encodeComponent(collectionId); |
| } |
| /* |
| postDonnees += "&cpr_abreviation=" + URL.encodeComponent(((ProjetListe) Registry.get(RegistreId.PROJETS)).get(collection.getIdProjet()).getAbreviation()); |
| postDonnees += "&cc_ce_projet=" + URL.encodeComponent(collection.getIdProjet()) + |
| "&cc_ce_mere=" + URL.encodeComponent(collection.getCollectionMereId()) + |
| "&cc_ce_structure=" + URL.encodeComponent(collection.getIdStructure()) + |
| "&cc_truk_identifiant_alternatif=" + URL.encodeComponent(collection.getIdAlternatif()) + |
| "&cc_truk_code=" + URL.encodeComponent(collection.getCode()) + |
| "&cc_nom=" + URL.encodeComponent(collection.getNom()) + |
| "&cc_truk_nom_alternatif=" + URL.encodeComponent(collection.getNomAlternatif()) + |
| "&cc_description=" + URL.encodeComponent(collection.getDescription()) + |
| "&cc_description_specialiste=" + URL.encodeComponent(collection.getDescriptionSpecialiste()) + |
| "&cc_historique=" + URL.encodeComponent(collection.getHistorique()) + |
| "&cc_truk_url=" + URL.encodeComponent(collection.getUrls()) + |
| "&cc_truk_groupement_principe=" + URL.encodeComponent(collection.getGroupementPrincipe()) + |
| "&cc_truk_groupement_but=" + URL.encodeComponent(collection.getGroupementBut()) + |
| "&cc_ce_type=" + URL.encodeComponent(collection.getTypeNcd()) + |
| "&cc_ce_type_depot=" + URL.encodeComponent(collection.getTypeDepot()) + |
| "&cc_cote=" + URL.encodeComponent(collection.getCote()) + |
| "&cc_truk_periode_constitution=" + URL.encodeComponent(collection.getPeriodeConstitution()) + |
| "&cc_truk_couverture_lieu=" + URL.encodeComponent(collection.getCouvertureLieu()) + |
| "&cc_ce_specimen_type=" + URL.encodeComponent(collection.getSpecimenType()) + |
| "&cc_specimen_type_nbre=" + URL.encodeComponent(collection.getSpecimenTypeNbre()) + |
| "&cc_ce_specimen_type_nbre_precision=" + URL.encodeComponent(collection.getSpecimenTypeNbrePrecision()) + |
| "&cc_ce_specimen_type_classement=" + URL.encodeComponent(collection.getSpecimenTypeClassement());*/ |
| postDonnees += "&" + collection.obtenirChainePOST(); |
| } |
| if (collection.getBotanique() != null) { |
| if (collectionId != null) { |
| postDonnees += "&ccb_id_collection=" + URL.encodeComponent(collectionId); |
| } |
| CollectionBotanique collectionBotanique = collection.getBotanique(); |
| /*postDonnees += "&ccb_nbre_echantillon=" + URL.encodeComponent(collectionBotanique.getNbreEchantillon()) + |
| "&ccb_ce_truk_type=" + URL.encodeComponent(collectionBotanique.getType()) + |
| "&ccb_truk_unite_rangement=" + URL.encodeComponent(collectionBotanique.getUniteRangement()) + |
| "&ccb_ce_unite_rangement_etat=" + URL.encodeComponent(collectionBotanique.getUniteRangementEtat()) + |
| "&ccb_truk_unite_base=" + URL.encodeComponent(collectionBotanique.getUniteBase()) + |
| "&ccb_truk_conservation_papier_type=" + URL.encodeComponent(collectionBotanique.getConservationPapierType()) + |
| "&ccb_truk_conservation_methode=" + URL.encodeComponent(collectionBotanique.getConservationMethode()) + |
| "&ccb_specimen_fixation_pourcent=" + URL.encodeComponent(collectionBotanique.getSpecimenFixationPourcent()) + |
| "&ccb_etiquette_fixation_pourcent=" + URL.encodeComponent(collectionBotanique.getEtiquetteFixationPourcent()) + |
| "&ccb_truk_specimen_fixation_methode=" + URL.encodeComponent(collectionBotanique.getSpecimenFixationMethode()) + |
| "&ccb_truk_etiquette_fixation_support=" + URL.encodeComponent(collectionBotanique.getEtiquetteFixationSupport()) + |
| "&ccb_truk_etiquette_fixation_specimen=" + URL.encodeComponent(collectionBotanique.getEtiquetteFixationSpecimen()) + |
| "&ccb_truk_etiquette_ecriture=" + URL.encodeComponent(collectionBotanique.getEtiquetteEcriture()) + |
| "&ccb_ce_traitement=" + URL.encodeComponent(collectionBotanique.getTraitement()) + |
| "&ccb_truk_traitement_poison=" + URL.encodeComponent(collectionBotanique.getTraitementPoison()) + |
| "&ccb_truk_traitement_insecte=" + URL.encodeComponent(collectionBotanique.getTraitementInsecte()) + |
| "&ccb_ce_etat_general=" + URL.encodeComponent(collectionBotanique.getEtatGeneral()) + |
| "&ccb_truk_degradation_specimen=" + URL.encodeComponent(collectionBotanique.getDegradationSpecimen()) + |
| "&ccb_truk_degradation_presentation=" + URL.encodeComponent(collectionBotanique.getDegradationPresentation()) + |
| "&ccb_ce_determination=" + URL.encodeComponent(collectionBotanique.getDetermination()) + |
| "&ccb_truk_nature=" + URL.encodeComponent(collectionBotanique.getNature()) + |
| "&ccb_specialite=" + URL.encodeComponent(collectionBotanique.getSpecialite()) + |
| "&ccb_recolte_date_debut=" + URL.encodeComponent(collectionBotanique.getRecolteDateDebut()) + |
| "&ccb_ce_recolte_date_debut_type=" + URL.encodeComponent(collectionBotanique.getRecolteDateDebutType()) + |
| "&ccb_recolte_date_fin=" + URL.encodeComponent(collectionBotanique.getRecolteDateFin()) + |
| "&ccb_ce_recolte_date_fin_type=" + URL.encodeComponent(collectionBotanique.getRecolteDateFinType()) + |
| "&ccb_annotation_classement=" + URL.encodeComponent(collectionBotanique.getClassementAnnotation()) + |
| "&ccb_ce_classement_etat=" + URL.encodeComponent(collectionBotanique.getClassementEtat()) + |
| "&ccb_truk_etiquette_renseignement=" + URL.encodeComponent(collectionBotanique.getEtiquetteRenseignement()) + |
| "&ccb_ce_precision_localite=" + URL.encodeComponent(collectionBotanique.getPrecisionLocalite()) + |
| "&ccb_ce_precision_date=" + URL.encodeComponent(collectionBotanique.getPrecisionDate()) + |
| "&ccb_annotation_diverse=" + URL.encodeComponent(collectionBotanique.getAnnotationsDiverses()) + |
| "&ccb_ce_collection_integre=" + URL.encodeComponent(collectionBotanique.getCollectionIntegre()) + |
| "&ccb_ce_collection_integre_info=" + URL.encodeComponent(collectionBotanique.getCollectionIntegreInfo()) + |
| "&ccb_ce_inventaire=" + URL.encodeComponent(collectionBotanique.getInventaire()) + |
| "&ccb_ce_inventaire_auteur=" + URL.encodeComponent(collectionBotanique.getInventaireAuteur()) + |
| "&ccb_ce_inventaire_forme=" + URL.encodeComponent(collectionBotanique.getInventaireForme()) + |
| "&ccb_inventaire_info=" + URL.encodeComponent(collectionBotanique.getInventaireInfo()) + |
| "&ccb_ce_truk_inventaire_digital=" + URL.encodeComponent(collectionBotanique.getInventaireDigital()) + |
| "&ccb_inventaire_digital_pourcent=" + URL.encodeComponent(collectionBotanique.getInventaireDigitalPourcent()) + |
| "&ccb_ce_inventaire_etat=" + URL.encodeComponent(collectionBotanique.getInventaireEtat()) + |
| "&ccb_inventaire_donnee_type=" + URL.encodeComponent(collectionBotanique.getInventaireDonneesTypes());*/ |
| postDonnees += "&" + collectionBotanique.obtenirChainePOST(); |
| } |
| return postDonnees; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/UniteBase.java |
|---|
| New file |
| 0,0 → 1,112 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.util.UtilString; |
| import com.extjs.gxt.ui.client.data.BaseModelData; |
| public class UniteBase extends BaseModelData { |
| private static final long serialVersionUID = 394843761854792528L; |
| public static final String COMPTE_EXACT = "E"; |
| public static final String COMPTE_APPROXIMATIF = "A"; |
| public UniteBase() { |
| } |
| public UniteBase(String id, String type, int nombre, String precision, String format, int nombreParts, String precisionPart, int nombreSp, String precisionSp) { |
| setId(id); |
| setType(type); |
| setNombre(nombre); |
| setPrecision(precision); |
| setFormat(format); |
| setTypeAutre(false); |
| } |
| public String getId() { |
| return renvoyerValeurCorrecte((String) get("id")); |
| } |
| public void setId(String id) { |
| set("id", id); |
| } |
| public String getType() { |
| return renvoyerValeurCorrecte((String) get("type")); |
| } |
| public void setType(String type) { |
| set("type", type); |
| } |
| public double getNombre() { |
| if (get("nombre") == null) { |
| return new Double(0); |
| } |
| return get("nombre"); |
| } |
| public void setNombre(double nombre) { |
| set("nombre", nombre); |
| } |
| public String getPrecision() { |
| return renvoyerValeurCorrecte((String) get("precision")); |
| } |
| public void setPrecision(String precision) { |
| set("precision", precision); |
| } |
| public String getFormat() { |
| return renvoyerValeurCorrecte((String) get("format")); |
| } |
| public void setFormat(String format) { |
| set("format", format); |
| } |
| public double getNombrePart() { |
| if (get("nombre_part") == null) { |
| return new Double(0); |
| } |
| return get("nombre_part"); |
| } |
| public void setNombrePart(double nombre) { |
| set("nombre_part", nombre); |
| } |
| public String getPrecisionPart() { |
| return renvoyerValeurCorrecte((String) get("precision_part")); |
| } |
| public void setPrecisionPart(String precision) { |
| set("precision_part", precision); |
| } |
| public double getNombreSp() { |
| if (get("nombre_sp") == null) { |
| return new Double(0); |
| } |
| return get("nombre_sp"); |
| } |
| public void setNombreSp(double nombre) { |
| set("nombre_sp", nombre); |
| } |
| public String getPrecisionSp() { |
| return renvoyerValeurCorrecte((String) get("precision_sp")); |
| } |
| public void setPrecisionSp(String precision) { |
| set("precision_sp", precision); |
| } |
| public boolean getTypeAutre() { |
| return get("type_autre"); |
| } |
| public void setTypeAutre(boolean bool) { |
| set("type_autre", bool); |
| } |
| private String renvoyerValeurCorrecte(String valeur) { |
| String valeurCorrecte = ""; |
| if (!UtilString.isEmpty(valeur)) { |
| valeurCorrecte = valeur; |
| } |
| return valeurCorrecte; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/UniteBase.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionACommentaire.java |
|---|
| New file |
| 0,0 → 1,110 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import org.tela_botanica.client.modeles.commentaire.Commentaire; |
| import com.google.gwt.json.client.JSONObject; |
| public class CollectionACommentaire extends aDonnee { |
| private static final long serialVersionUID = 8751553802444398035L; |
| public static final String PREFIXE = "ccac"; |
| private Commentaire commentaireLiee = null; |
| public static String[] champsObligatoires = {"cc_id_collection", "ccac_id_commentaire"}; |
| public CollectionACommentaire() { |
| initialiser(new JSONObject(), false); |
| } |
| public CollectionACommentaire(JSONObject collectionACommentaireListe) { |
| initialiser(collectionACommentaireListe, true); |
| } |
| public CollectionACommentaire(JSONObject collectionACommentaireListe, boolean chargerCommentaire) { |
| initialiser(collectionACommentaireListe, chargerCommentaire); |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| private void initialiser(JSONObject collectionACommentaireListe, boolean chargerCommentaire) { |
| if (chargerCommentaire) { |
| setCommentaire(new Commentaire(collectionACommentaireListe, false)); |
| } else { |
| setCommentaire(new Commentaire()); |
| } |
| initialiserModele(collectionACommentaireListe); |
| initialiserChampsPourGrille(); |
| } |
| // COMMENTAIRE |
| public Commentaire getCommentaire() { |
| return commentaireLiee; |
| } |
| public void setCommentaire(Commentaire commentaire) { |
| commentaireLiee = commentaire; |
| initialiserChampsPourGrille(); |
| if (commentaire != null) { |
| setIdCommentaire(commentaire.getId()); |
| } |
| } |
| private void initialiserChampsPourGrille() { |
| set("_type_", getType()); |
| set("_titre_", getCommentaire().getTitre()); |
| set("_texte_", getCommentaire().getTexte()); |
| set("_ponderation_", getCommentaire().getPonderation()); |
| set("_public_", getCommentaire().getPublic()); |
| set("_etat_", ""); |
| } |
| // ID |
| /** Génère un identifiant de CollectionACommentaire. |
| * |
| * C'est une concaténation des clés primaires de la table coel_collection_a_commentaire séparées par un tiret "-". |
| * |
| * @return identifiant unique d'une relation "collection à commentaire". |
| */ |
| public String getId() { |
| String idCollection = getIdCollection(); |
| String idCommentaire = getIdCommentaire(); |
| if (idCollection.equals("") && idCommentaire.equals("")) { |
| return null; |
| } else { |
| return (idCollection+"-"+idCommentaire); |
| } |
| } |
| //+---------------------------------------------------------------------------------------------------------------+ |
| // CHAMPS PROVENANT de la TABLE COEL_COLLECTION_A_COMMENTAIRE |
| // ID COLLECTION |
| public String getIdCollection() { |
| return renvoyerValeurCorrecte("id_collection"); |
| } |
| public void setIdCollection(String idCollection) { |
| set("id_collection", idCollection); |
| } |
| // ID COMENTAIRE |
| public String getIdCommentaire() { |
| return renvoyerValeurCorrecte("id_commentaire"); |
| } |
| public void setIdCommentaire(String ic) { |
| set("id_commentaire", ic); |
| } |
| // TRUCK TYPE |
| public String getType() { |
| return renvoyerValeurCorrecte("truk_type"); |
| } |
| public void setType(String type) { |
| set("truk_type", type); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionACommentaire.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionACommentaireListe.java |
|---|
| New file |
| 0,0 → 1,34 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| public class CollectionACommentaireListe extends aDonneeListe<CollectionACommentaire> { |
| private static final long serialVersionUID = 1L; |
| public CollectionACommentaireListe() { |
| super(); |
| } |
| public CollectionACommentaireListe(int taille) { |
| super(taille); |
| } |
| public CollectionACommentaireListe(JSONArray collectionACommentaires) { |
| super(collectionACommentaires.size()) ; |
| final int taillemax = collectionACommentaires.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject collectionACommentaireCourant = collectionACommentaires.get(i).isObject() ; |
| if (collectionACommentaireCourant != null) { |
| CollectionACommentaire collectionACommentaire = new CollectionACommentaire(collectionACommentaireCourant); |
| this.put(collectionACommentaire.getId(), collectionACommentaire); |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionACommentaireListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionACommentaireAsyncDao.java |
|---|
| New file |
| 0,0 → 1,142 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONValue; |
| public class CollectionACommentaireAsyncDao { |
| private static final String SERVICE_NOM = "CoelCollectionACommentaire"; |
| public static final String SUPPRESSION_PAR_COLLECTION = "SuppressionParCollection"; |
| public static final String SUPPRESSION_PAR_COMMENTAIRE = "SuppressionParCommentaire"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public CollectionACommentaireAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| CollectionACommentaireAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante; |
| utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId(); |
| } |
| public void selectionner(final String collectionId, final Integer seqId) { |
| String[] parametres = {collectionId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| Information info = new Information("liste_collection_a_commentaire"); |
| if (responseValue != null) { |
| // Si la requête est un succès, reception d'un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // Transformation du tableau JSON réponse en ListCommentaier |
| CollectionACommentaireListe commentaires = new CollectionACommentaireListe(reponse); |
| info.setDonnee(0, commentaires); |
| // 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 { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un talbeau JSON et vaut : "+responseValue.toString(), null); |
| } |
| } else { |
| if (collectionId == null) { |
| // Dans le cas, où nous demandons toutes les relations Collection à Commentaires et qu'il n'y en a pas, nous retournons un message d'information |
| info.setMessage("Aucune relations entre la collection et les commentaires"); |
| if (seqId != null) { |
| Reponse reponseRequete = new Reponse(info, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| vueARafraichir.rafraichir(info); |
| } |
| } |
| } |
| } |
| }); |
| } |
| public void ajouter(String collectionId, CollectionACommentaire commentaires) { |
| String postDonneesEncodees = construirePost(collectionId, commentaires); |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| Information info = new Information("ajout_collection_a_commentaire"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void modifier(CollectionACommentaire commentaires) { |
| String[] parametres = {commentaires.getIdCollection(), commentaires.getIdCommentaire()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| String postDonneesEncodees = construirePost(commentaires.getIdCollection(), commentaires); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| Information info = new Information("modif_collection_a_commentaire"); |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void supprimer(String idCollectionACommentaire, String mode) { |
| String[] parametres = {utilisateurId, idCollectionACommentaire, mode}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("suppression_collection_a_commentaire"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| private String construirePost(String collectionId, CollectionACommentaire commentaire) { |
| String postDonnees = "cmhl_ce_modifier_par=" + URL.encodeComponent(utilisateurId) + |
| "&ccac_id_collection=" + URL.encodeComponent(collectionId) + |
| "&ccac_id_commentaire=" + URL.encodeComponent(commentaire.getIdCommentaire()) + |
| "&ccac_truk_type=" + URL.encodeComponent(commentaire.getType()); |
| return postDonnees; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionACommentaireAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionBotanique.java |
|---|
| New file |
| 0,0 → 1,393 |
| package org.tela_botanica.client.modeles.collection; |
| import java.util.Iterator; |
| import java.util.Set; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import com.google.gwt.json.client.JSONObject; |
| public class CollectionBotanique extends aDonnee { |
| private static final long serialVersionUID = -6659148189825855729L; |
| public static final String PREFIXE = "ccb"; |
| public static String[] champsObligatoires = {"ccb_id_collection"}; |
| public CollectionBotanique() { |
| } |
| public CollectionBotanique(JSONObject botanique) { |
| // l'objet JSON est une table de hachage |
| Set<String> im = botanique.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| if (cle.startsWith(PREFIXE+"_")) { |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = ""; |
| if (botanique.get(cle).isString() != null) { |
| valeur = botanique.get(cle).isString().stringValue(); |
| } |
| this.set(cleObjet, valeur); |
| } |
| } |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| // ID |
| public String getId() { |
| return renvoyerValeurCorrecte("id_collection"); |
| } |
| public void setId(String idCollection) { |
| this.set("id_collection", idCollection); |
| } |
| // NBRE ECHANTILLON |
| public String getNbreEchantillon() { |
| return renvoyerValeurCorrecte("nbre_echantillon"); |
| } |
| public void setNbreEchantillon(String type) { |
| this.set("nbre_echantillon", type); |
| } |
| // TYPE |
| public String getType() { |
| return renvoyerValeurCorrecte("ce_truk_type"); |
| } |
| public void setType(String type) { |
| this.set("ce_truk_type", type); |
| } |
| // UNITÉ RANGEMENT |
| public String getUniteRangement() { |
| return renvoyerValeurCorrecte("truk_unite_rangement"); |
| } |
| public void setUniteRangement(String uniteRangement) { |
| this.set("truk_unite_rangement", uniteRangement); |
| } |
| // UNITÉ RANGEMENT ÉTAT |
| public String getUniteRangementEtat() { |
| return renvoyerValeurCorrecte("ce_unite_rangement_etat"); |
| } |
| public void setUniteRangementEtat(String uniteRangementEtat) { |
| this.set("ce_unite_rangement_etat", uniteRangementEtat); |
| } |
| // UNITÉ BASE |
| public String getUniteBase() { |
| return renvoyerValeurCorrecte("truk_unite_base"); |
| } |
| public void setUniteBase(String uniteBase) { |
| this.set("truk_unite_base", uniteBase); |
| } |
| // CONSERVATION PAPIER TYPE |
| public String getConservationPapierType() { |
| return renvoyerValeurCorrecte("truk_conservation_papier_type"); |
| } |
| public void setConservationPapierType(String typePapierConservation) { |
| this.set("truk_conservation_papier_type", typePapierConservation); |
| } |
| // CONSERVATION MÉTHODE |
| public String getConservationMethode() { |
| return renvoyerValeurCorrecte("truk_conservation_methode"); |
| } |
| public void setConservationMethode(String methodeConservation) { |
| this.set("truk_conservation_methode", methodeConservation); |
| } |
| // ÉTIQUETTE FIXATION POURCENT |
| public String getEtiquetteFixationPourcent() { |
| return renvoyerValeurCorrecte("etiquette_fixation_pourcent"); |
| } |
| public void setEtiquetteFixationPourcent(String etiquetteFixationPourcent) { |
| this.set("etiquette_fixation_pourcent", etiquetteFixationPourcent); |
| } |
| // SPÉCIMEN FIXATION POURCENT |
| public String getSpecimenFixationPourcent() { |
| return renvoyerValeurCorrecte("specimen_fixation_pourcent"); |
| } |
| public void setSpecimenFixationPourcent(String specimenFixationPourcent) { |
| this.set("specimen_fixation_pourcent", specimenFixationPourcent); |
| } |
| // SPÉCIMEN FIXATION MÉTHODE |
| public String getSpecimenFixationMethode() { |
| return renvoyerValeurCorrecte("truk_specimen_fixation_methode"); |
| } |
| public void setSpecimenFixationMethode(String specimenFixationMethode) { |
| this.set("truk_specimen_fixation_methode", specimenFixationMethode); |
| } |
| // ÉTIQUETTE FIXATION SUPPORT |
| public String getEtiquetteFixationSupport() { |
| return renvoyerValeurCorrecte("truk_etiquette_fixation_support"); |
| } |
| public void setEtiquetteFixationSupport(String etiquetteFixationSupport) { |
| this.set("truk_etiquette_fixation_support", etiquetteFixationSupport); |
| } |
| // ÉTIQUETTE FIXATION SPECIMEN |
| public String getEtiquetteFixationSpecimen() { |
| return renvoyerValeurCorrecte("truk_etiquette_fixation_specimen"); |
| } |
| public void setEtiquetteFixationSpecimen(String etiquetteFixationSpecimen) { |
| this.set("truk_etiquette_fixation_specimen", etiquetteFixationSpecimen); |
| } |
| // ÉTIQUETTE ÉCRITURE |
| public String getEtiquetteEcriture() { |
| return renvoyerValeurCorrecte("truk_etiquette_ecriture"); |
| } |
| public void setEtiquetteEcriture(String etiquetteEcriture) { |
| this.set("truk_etiquette_ecriture", etiquetteEcriture); |
| } |
| // TRAITEMENT |
| public String getTraitement() { |
| return renvoyerValeurCorrecte("ce_traitement"); |
| } |
| public void setTraitement(String traitement) { |
| this.set("ce_traitement", traitement); |
| } |
| // TRAITEMENT POISON |
| public String getTraitementPoison() { |
| return renvoyerValeurCorrecte("truk_traitement_poison"); |
| } |
| public void setTraitementPoison(String traitementPoison) { |
| this.set("truk_traitement_poison", traitementPoison); |
| } |
| // TRAITEMENT INSECTE |
| public String getTraitementInsecte() { |
| return renvoyerValeurCorrecte("truk_traitement_insecte"); |
| } |
| public void setTraitementInsecte(String traitementInsecte) { |
| this.set("truk_traitement_insecte", traitementInsecte); |
| } |
| // ÉTAT GÉNÉRAL |
| public String getEtatGeneral() { |
| return renvoyerValeurCorrecte("ce_etat_general"); |
| } |
| public void setEtatGeneral(String etatGeneral) { |
| this.set("ce_etat_general", etatGeneral); |
| } |
| // DÉGRADATION SPECIMEN |
| public String getDegradationSpecimen() { |
| return renvoyerValeurCorrecte("truk_degradation_specimen"); |
| } |
| public void setDegradationSpecimen(String degradationSpecimen) { |
| this.set("truk_degradation_specimen", degradationSpecimen); |
| } |
| // DÉGRADATION PRÉSENTATION |
| public String getDegradationPresentation() { |
| return renvoyerValeurCorrecte("truk_degradation_presentation"); |
| } |
| public void setDegradationPresentation(String degradationPresentation) { |
| this.set("truk_degradation_presentation", degradationPresentation); |
| } |
| // DÉTERMINATION |
| public String getDetermination() { |
| return renvoyerValeurCorrecte("ce_determination"); |
| } |
| public void setDetermination(String determination) { |
| this.set("ce_determination", determination); |
| } |
| // NATURE |
| public String getNature() { |
| return renvoyerValeurCorrecte("truk_nature"); |
| } |
| public void setNature(String nature) { |
| this.set("truk_nature", nature); |
| } |
| // SPÉCIALITÉ |
| public String getSpecialite() { |
| return renvoyerValeurCorrecte("specialite"); |
| } |
| public void setSpecialite(String specialite) { |
| this.set("specialite", specialite); |
| } |
| // RÉCOLTE DATE DÉBUT |
| public String getRecolteDateDebut() { |
| return renvoyerValeurCorrecte("recolte_date_debut"); |
| } |
| public void setRecolteDateDebut(String dateDebut) { |
| this.set("recolte_date_debut", dateDebut); |
| } |
| // RÉCOLTE DATE DÉBUT TYPE |
| public String getRecolteDateDebutType() { |
| return renvoyerValeurCorrecte("ce_recolte_date_debut_type"); |
| } |
| public void setRecolteDateDebutType(String dateDebutType) { |
| this.set("ce_recolte_date_debut_type", dateDebutType); |
| } |
| // RÉCOLTE DATE FIN |
| public String getRecolteDateFin() { |
| return renvoyerValeurCorrecte("recolte_date_fin"); |
| } |
| public void setRecolteDateFin(String dateFin) { |
| this.set("recolte_date_fin", dateFin); |
| } |
| // RÉCOLTE DATE DÉBUT TYPE |
| public String getRecolteDateFinType() { |
| return renvoyerValeurCorrecte("ce_recolte_date_fin_type"); |
| } |
| public void setRecolteDateFinType(String dateFinType) { |
| this.set("ce_recolte_date_fin_type", dateFinType); |
| } |
| // CLASSEMENT ANNOTATION |
| public String getClassementAnnotation() { |
| return renvoyerValeurCorrecte("annotation_classement"); |
| } |
| public void setClassementAnnotation(String annotation) { |
| this.set("annotation_classement", annotation); |
| } |
| // CLASSEMENT ÉTAT |
| public String getClassementEtat() { |
| return renvoyerValeurCorrecte("ce_classement_etat"); |
| } |
| public void setClassementEtat(String classementEtat) { |
| this.set("ce_classement_etat", classementEtat); |
| } |
| // ÉTIQUETTE RENSEIGNEMENT |
| public String getEtiquetteRenseignement() { |
| return renvoyerValeurCorrecte("truk_etiquette_renseignement"); |
| } |
| public void setEtiquetteRenseignement(String etiquetteRenseignement) { |
| this.set("truk_etiquette_renseignement", etiquetteRenseignement); |
| } |
| // PRÉCISION LOCALITÉ |
| public String getPrecisionLocalite() { |
| return renvoyerValeurCorrecte("ce_precision_localite"); |
| } |
| public void setPrecisionLocalite(String precisionLocalite) { |
| this.set("ce_precision_localite", precisionLocalite); |
| } |
| // PRÉCISION DATE |
| public String getPrecisionDate() { |
| return renvoyerValeurCorrecte("ce_precision_date"); |
| } |
| public void setPrecisionDate(String precisionDate) { |
| this.set("ce_precision_date", precisionDate); |
| } |
| // ANNOTATIONS DIVERSES |
| public String getAnnotationsDiverses() { |
| return renvoyerValeurCorrecte("annotation_diverse"); |
| } |
| public void setAnnotationsDiverses(String annotation) { |
| this.set("annotation_diverse", annotation); |
| } |
| // COLLECTION INTÉGRÉ |
| public String getCollectionIntegre() { |
| return renvoyerValeurCorrecte("ce_collection_integre"); |
| } |
| public void setCollectionIntegre(String collectionIntegre) { |
| this.set("ce_collection_integre", collectionIntegre); |
| } |
| // COLLECTION INTÉGRÉ INFO |
| public String getCollectionIntegreInfo() { |
| return renvoyerValeurCorrecte("ce_collection_integre_info"); |
| } |
| public void setCollectionIntegreInfo(String collectionIntegreInfo) { |
| this.set("ce_collection_integre_info", collectionIntegreInfo); |
| } |
| // INVENTAIRE |
| public String getInventaire() { |
| return renvoyerValeurCorrecte("ce_inventaire"); |
| } |
| public void setInventaire(String inventaire) { |
| this.set("ce_inventaire", inventaire); |
| } |
| // INVENTAIRE AUTEUR |
| public String getInventaireAuteur() { |
| return renvoyerValeurCorrecte("ce_inventaire_auteur"); |
| } |
| public void setInventaireAuteur(String inventaireAuteur) { |
| this.set("ce_inventaire_auteur", inventaireAuteur); |
| } |
| // INVENTAIRE FORME |
| public String getInventaireForme() { |
| return renvoyerValeurCorrecte("ce_inventaire_forme"); |
| } |
| public void setInventaireForme(String inventaireForme) { |
| this.set("ce_inventaire_forme", inventaireForme); |
| } |
| // INVENTAIRE INFO |
| public String getInventaireInfo() { |
| return renvoyerValeurCorrecte("inventaire_info"); |
| } |
| public void setInventaireInfo(String inventaireInfo) { |
| this.set("inventaire_info", inventaireInfo); |
| } |
| // INVENTAIRE DIGITAL |
| public String getInventaireDigital() { |
| return renvoyerValeurCorrecte("ce_truk_inventaire_digital"); |
| } |
| public void setInventaireDigital(String inventaireDigital) { |
| this.set("ce_truk_inventaire_digital", inventaireDigital); |
| } |
| // INVENTAIRE DIGITAL POURCENT |
| public String getInventaireDigitalPourcent() { |
| return renvoyerValeurCorrecte("inventaire_digital_pourcent"); |
| } |
| public void setInventaireDigitalPourcent(String inventaireDigitalPourcent) { |
| this.set("inventaire_digital_pourcent", inventaireDigitalPourcent); |
| } |
| // INVENTAIRE ETAT |
| public String getInventaireEtat() { |
| return renvoyerValeurCorrecte("ce_inventaire_etat"); |
| } |
| public void setInventaireEtat(String inventaireEtat) { |
| this.set("ce_inventaire_etat", inventaireEtat); |
| } |
| //DELETEME ::: INVENTAIRE DONNÉES TYPES |
| /*public String getInventaireDonneesTypes() { |
| return renvoyerValeurCorrecte("inventaire_donnee_type"); |
| } |
| public void setInventaireDonneesTypes(String inventaireDonneesTypes) { |
| this.set("inventaire_donnee_type", inventaireDonneesTypes); |
| }*/ |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionBotanique.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/UniteRangement.java |
|---|
| New file |
| 0,0 → 1,78 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.util.UtilString; |
| import com.extjs.gxt.ui.client.data.BaseModelData; |
| public class UniteRangement extends BaseModelData { |
| private static final long serialVersionUID = 394843761854792528L; |
| public static final String COMPTE_EXACT = "E"; |
| public static final String COMPTE_APPROXIMATIF = "A"; |
| public UniteRangement() { |
| } |
| public UniteRangement(String id, String type, int nombre, String precision, String format) { |
| setId(id); |
| setType(type); |
| setNombre(nombre); |
| setPrecision(precision); |
| setFormat(format); |
| setTypeAutre(false); |
| } |
| public String getId() { |
| return renvoyerValeurCorrecte((String) get("id")); |
| } |
| public void setId(String id) { |
| set("id", id); |
| } |
| public String getType() { |
| return renvoyerValeurCorrecte((String) get("type")); |
| } |
| public void setType(String type) { |
| set("type", type); |
| } |
| public double getNombre() { |
| if (get("nombre") == null) { |
| return new Double(0); |
| } |
| return get("nombre"); |
| } |
| public void setNombre(double nombre) { |
| set("nombre", nombre); |
| } |
| public String getPrecision() { |
| return renvoyerValeurCorrecte((String) get("precision")); |
| } |
| public void setPrecision(String precision) { |
| set("precision", precision); |
| } |
| public String getFormat() { |
| return renvoyerValeurCorrecte((String) get("format")); |
| } |
| public void setFormat(String format) { |
| set("format", format); |
| } |
| public boolean getTypeAutre() { |
| return get("type_autre"); |
| } |
| public void setTypeAutre(boolean bool) { |
| set("type_autre", bool); |
| } |
| private String renvoyerValeurCorrecte(String valeur) { |
| String valeurCorrecte = ""; |
| if (!UtilString.isEmpty(valeur)) { |
| valeurCorrecte = valeur; |
| } |
| return valeurCorrecte; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/UniteRangement.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionAPersonne.java |
|---|
| New file |
| 0,0 → 1,109 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import org.tela_botanica.client.modeles.personne.Personne; |
| import com.google.gwt.json.client.JSONObject; |
| public class CollectionAPersonne extends aDonnee { |
| private static final long serialVersionUID = 1L; |
| public static final String PREFIXE = "ccap"; |
| private Personne personneLiee = null; |
| public static String[] champsObligatoires = {"ccap_id_collection", "ccap_id_personne", "ccap_id_role"}; |
| public CollectionAPersonne() { |
| initialiser(new JSONObject()); |
| } |
| public CollectionAPersonne(JSONObject collectionAPersonneListe) { |
| initialiser(collectionAPersonneListe); |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| private void initialiser(JSONObject collectionAPersonneListe) { |
| setPersonne(new Personne(collectionAPersonneListe)); |
| initialiserModele(collectionAPersonneListe); |
| initialiserChampsPourGrille(); |
| } |
| // PERSONNE |
| public Personne getPersonne() { |
| return personneLiee; |
| } |
| public void setPersonne(Personne personne) { |
| personneLiee = personne; |
| initialiserChampsPourGrille(); |
| if (personne != null) { |
| setIdPersonne(personne.getId()); |
| } |
| } |
| private void initialiserChampsPourGrille() { |
| set("_role_", getIdRole()); |
| set("fmt_nom_complet", getPersonne().getNomComplet()); |
| set("nom", getPersonne().getNom()); |
| set("prenom", getPersonne().getPrenom()); |
| set("naissance_date", getPersonne().getNaissanceDate()); |
| set("naissance_lieu", getPersonne().getNaissanceLieu()); |
| set("_deces_", getPersonne().getDeces()); |
| set("deces_date", getPersonne().getDecesDate()); |
| set("deces_lieu", getPersonne().getDecesLieu()); |
| set("_etat_", ""); |
| } |
| // ID |
| /** Génère un identifiant de CollectionAPersonne. |
| * |
| * C'est une concaténation des clés primaires de la table coel_collection_a_personne séparées par un tiret "-". |
| * |
| * @return identifiant unique d'une relation "collection à personne". |
| */ |
| public String getId() { |
| String idCollection = getIdCollection(); |
| String idPersonne = getIdPersonne(); |
| String idRole = getIdRole(); |
| if (idCollection.equals("") && idPersonne.equals("") && idRole.equals("")) { |
| return null; |
| } else { |
| return (idCollection+"-"+idPersonne+"-"+idRole); |
| } |
| } |
| //+---------------------------------------------------------------------------------------------------------------+ |
| // CHAMPS PROVENANT de la TABLE COEL_COLLECTION_A_PERSONNE |
| // ID COLLECTION |
| public String getIdCollection() { |
| return renvoyerValeurCorrecte("id_collection"); |
| } |
| public void setIdCollection(String idCollection) { |
| set("id_collection", idCollection); |
| } |
| // ID PERSONNE |
| public String getIdPersonne() { |
| return renvoyerValeurCorrecte("id_personne"); |
| } |
| public void setIdPersonne(String ip) { |
| set("id_personne", ip); |
| } |
| // ID RôLE |
| public String getIdRole() { |
| return renvoyerValeurCorrecte("id_role"); |
| } |
| public void setIdRole(String ir) { |
| set("id_role", ir); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionAPersonne.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionAPublication.java |
|---|
| New file |
| 0,0 → 1,99 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import org.tela_botanica.client.modeles.publication.Publication; |
| import com.google.gwt.json.client.JSONObject; |
| public class CollectionAPublication extends aDonnee { |
| private static final long serialVersionUID = 1L; |
| public static final String PREFIXE = "ccapu"; |
| private Publication publicationLiee = null; |
| public static String[] champsObligatoires = {"ccapu_id_collection", "ccapu_id_publication"}; |
| public CollectionAPublication() { |
| initialiser(new JSONObject()); |
| } |
| public CollectionAPublication(JSONObject collectionAPublicationListe) { |
| initialiser(collectionAPublicationListe); |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| private void initialiser(JSONObject collectionAPublicationListe) { |
| setPublication(new Publication(collectionAPublicationListe)); |
| initialiserChampsPourGrille(); |
| initialiserModele(collectionAPublicationListe); |
| } |
| // PUBLICATION |
| public Publication getPublication() { |
| return publicationLiee; |
| } |
| public void setPublication(Publication publication) { |
| publicationLiee = publication; |
| initialiserChampsPourGrille(); |
| if (publication != null) { |
| setIdPublication(publication.getId()); |
| } |
| } |
| private void initialiserChampsPourGrille() { |
| set("fmt_auteur", getPublication().getAuteur()); |
| set("titre", getPublication().getTitre()); |
| set("collection", getPublication().getCollection()); |
| set("_editeur_", ""); |
| set("_annee_", ""); |
| set("indication_nvt", getPublication().getIndicationNvt()); |
| set("fascicule", getPublication().getFascicule()); |
| set("truk_pages", getPublication().getPages()); |
| set("_etat_", ""); |
| } |
| // ID |
| /** Génère un identifiant de CollectionAPersonne. |
| * |
| * C'est une concaténation des clés primaires de la table coel_collection_a_personne séparées par un tiret "-". |
| * |
| * @return identifiant unique d'une relation "collection à personne". |
| */ |
| public String getId() { |
| String idCollection = getIdCollection(); |
| String idPublication = getIdPublication(); |
| if (idCollection.equals("") && idPublication.equals("")) { |
| return null; |
| } else { |
| return (idCollection+"-"+idPublication); |
| } |
| } |
| //+---------------------------------------------------------------------------------------------------------------+ |
| // CHAMPS PROVENANT de la TABLE COEL_COLLECTION_A_PERSONNE |
| // ID COLLECTION |
| public String getIdCollection() { |
| return renvoyerValeurCorrecte("id_collection"); |
| } |
| public void setIdCollection(String idCollection) { |
| set("id_collection", idCollection); |
| } |
| // ID PUBLICATION |
| public String getIdPublication() { |
| return renvoyerValeurCorrecte("id_publication"); |
| } |
| public void setIdPublication(String ip) { |
| set("id_publication", ip); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionAPublication.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionAPersonneListe.java |
|---|
| New file |
| 0,0 → 1,41 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Table de hachage composée d'informations sur les Structures et les Personnes, renvoyé par un objet de type DAO |
| * La clé est une concaténation des clés primaires de la table coel_structure_a_personne séparées par un tiret "-". |
| * |
| * @author david delon |
| * |
| */ |
| public class CollectionAPersonneListe extends aDonneeListe<CollectionAPersonne> { |
| private static final long serialVersionUID = 1L; |
| public CollectionAPersonneListe() { |
| super(); |
| } |
| public CollectionAPersonneListe(int taille) { |
| super(taille); |
| } |
| public CollectionAPersonneListe(JSONArray structures) { |
| super(structures.size()) ; |
| final int taillemax = structures.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject collectionAPersonneCourante = structures.get(i).isObject() ; |
| if (collectionAPersonneCourante != null) { |
| CollectionAPersonne collectionAPersonne = new CollectionAPersonne(collectionAPersonneCourante); |
| this.put(collectionAPersonne.getId(), collectionAPersonne); |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionAPersonneListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionAPublicationListe.java |
|---|
| New file |
| 0,0 → 1,41 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Table de hachage composée d'informations sur les Structures et les Personnes, renvoyé par un objet de type DAO |
| * La clé est une concaténation des clés primaires de la table coel_structure_a_personne séparées par un tiret "-". |
| * |
| * @author david delon |
| * |
| */ |
| public class CollectionAPublicationListe extends aDonneeListe<CollectionAPublication> { |
| private static final long serialVersionUID = 1L; |
| public CollectionAPublicationListe() { |
| super(); |
| } |
| public CollectionAPublicationListe(int taille) { |
| super(taille); |
| } |
| public CollectionAPublicationListe(JSONArray publications) { |
| super(publications.size()) ; |
| final int taillemax = publications.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject collectionAPublicationCourante = publications.get(i).isObject() ; |
| if (collectionAPublicationCourante != null) { |
| CollectionAPublication collectionAPublication = new CollectionAPublication(collectionAPublicationCourante); |
| this.put(collectionAPublication.getId(), collectionAPublication); |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionAPublicationListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionAPersonneAsyncDao.java |
|---|
| New file |
| 0,0 → 1,132 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONValue; |
| public class CollectionAPersonneAsyncDao { |
| private static final String SERVICE_NOM = "CoelCollectionAPersonne"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public CollectionAPersonneAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| CollectionAPersonneAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante; |
| utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId(); |
| } |
| public void selectionner(final String collectionId, final String roleId, final Integer seqId) { |
| String[] parametres = {collectionId, roleId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| Information info = new Information("liste_collection_a_personne"); |
| if (responseValue != null) { |
| // Si la requête est un succès, reception d'un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // Transformation du tableau JSON réponse en ListeInstitution |
| CollectionAPersonneListe personnes = new CollectionAPersonneListe(reponse); |
| 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 { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un talbeau JSON et vaut : "+responseValue.toString(), null); |
| } |
| } else { |
| if (collectionId == null) { |
| // Dans le cas, où nous demandons toutes les relations Collection à Personne et qu'il n'y en a pas, nous retournons un message d'information |
| info.setMessage("Aucune relations entre la collection et les personnes"); |
| vueARafraichir.rafraichir(info); |
| } |
| } |
| } |
| }); |
| } |
| public void ajouter(String collectionId, CollectionAPersonne personnes) { |
| String postDonneesEncodees = construirePost(collectionId, personnes); |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| Information info = new Information("ajout_collection_a_personne"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void modifier(CollectionAPersonne personnes) { |
| String[] parametres = {personnes.getIdCollection(), personnes.getIdPersonne(), personnes.getIdRole()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| String postDonneesEncodees = construirePost(personnes.getIdCollection(), personnes); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| Information info = new Information("modif_collection_a_personne"); |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void supprimer(String idCollectionAPersonne) { |
| String[] parametres = {utilisateurId, idCollectionAPersonne}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("suppression_collection_a_personne"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| private String construirePost(String collectionId, CollectionAPersonne personne) { |
| String postDonnees = "cmhl_ce_modifier_par=" + URL.encodeComponent(utilisateurId) + |
| "&ccap_id_collection=" + URL.encodeComponent(collectionId) + |
| "&ccap_id_personne=" + URL.encodeComponent(personne.getIdPersonne()) + |
| "&ccap_id_role=" + URL.encodeComponent(personne.getIdRole()); |
| return postDonnees; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionAPersonneAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/collection/CollectionAPublicationAsyncDao.java |
|---|
| New file |
| 0,0 → 1,131 |
| package org.tela_botanica.client.modeles.collection; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONValue; |
| public class CollectionAPublicationAsyncDao { |
| private static final String SERVICE_NOM = "CoelCollectionAPublication"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public CollectionAPublicationAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| CollectionAPublicationAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante; |
| utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId(); |
| } |
| public void selectionner(final String collectionId, final Integer seqId) { |
| String[] parametres = {collectionId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| Information info = new Information("liste_collection_a_publication"); |
| if (responseValue != null) { |
| // Si la requête est un succès, reception d'un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // Transformation du tableau JSON réponse en ListeInstitution |
| CollectionAPublicationListe publications = new CollectionAPublicationListe(reponse); |
| info.setDonnee(0, publications); |
| // 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 { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un talbeau JSON et vaut : "+responseValue.toString(), null); |
| } |
| } else { |
| if (collectionId == null) { |
| // Dans le cas, où nous demandons toutes les relations Collection à Publication et qu'il n'y en a pas, nous retournons un message d'information |
| info.setMessage("Aucune relations entre la collection et les publications"); |
| vueARafraichir.rafraichir(info); |
| } |
| } |
| } |
| }); |
| } |
| public void ajouter(String collectionId, CollectionAPublication publications) { |
| String postDonneesEncodees = construirePost(collectionId, publications); |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| Information info = new Information("ajout_collection_a_publication"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void modifier(CollectionAPublication publications) { |
| String[] parametres = {publications.getIdCollection(), publications.getIdPublication()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| String postDonneesEncodees = construirePost(publications.getIdCollection(), publications); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| Information info = new Information("modif_collection_a_publication"); |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void supprimer(String idCollectionAPublication) { |
| String[] parametres = {utilisateurId, idCollectionAPublication}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("suppression_collection_a_publication"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| private String construirePost(String collectionId, CollectionAPublication publication) { |
| String postDonnees = "cmhl_ce_modifier_par=" + URL.encodeComponent(utilisateurId) + |
| "&ccapu_id_collection=" + URL.encodeComponent(collectionId) + |
| "&ccapu_id_publication=" + URL.encodeComponent(publication.getIdPublication()); |
| return postDonnees; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/collection/CollectionAPublicationAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/structure/StructureAPersonne.java |
|---|
| New file |
| 0,0 → 1,354 |
| package org.tela_botanica.client.modeles.structure; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import org.tela_botanica.client.modeles.personne.Personne; |
| import org.tela_botanica.client.util.UtilString; |
| import com.google.gwt.json.client.JSONObject; |
| public class StructureAPersonne extends aDonnee { |
| private static final long serialVersionUID = -7265602594281982891L; |
| public static final String PREFIXE = "csap"; |
| public static final String FONCTION_DIRECTEUR = "2028"; |
| public static final String FONCTION_CONSERVATEUR = "2029"; |
| public static final String FONCTION_TECHNICIEN = "2030"; |
| public static final String ROLE_ADMIN = "2026"; |
| public static final String ROLE_EQUIPE = "2027"; |
| public static final String ETAT_AJOUTE = "A"; |
| public static String[] champsObligatoires = {"csap_id_personne", "csap_id_structure", "csap_id_role", "cp_id_personne"}; |
| public StructureAPersonne() { |
| // Définition des valeurs par défaut de variables obligatoires vis à vis de l'utilisation de l'objet |
| set("contact", false); |
| set("fonction", ""); |
| set("statut", ""); |
| set("travail", 0); |
| } |
| public StructureAPersonne(JSONObject personnel) { |
| // Définition des valeurs par défaut de variables obligatoires vis à vis de l'utilisation de l'objet |
| set("contact", false); |
| set("fonction", ""); |
| set("statut", ""); |
| set("travail", 0); |
| // L'objet JSON est une table de hachage |
| Set<String> im = personnel.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| if (cle.startsWith(PREFIXE+"_")) { |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = ""; |
| if (personnel.get(cle).isString() != null) { |
| valeur = personnel.get(cle).isString().stringValue(); |
| } |
| set(cleObjet, valeur); |
| if (cle.equals("mark_contact")) { |
| set("contact", (valeur.equals("1") ? true : false)); |
| } else if (cle.equals("bota_travail_hebdo_tps")) { |
| set("travail", Integer.parseInt(valeur)); |
| } |
| } |
| if (cle.startsWith(Personne.PREFIXE+"_")) { |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+Personne.PREFIXE+"_", ""); |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = ""; |
| if (personnel.get(cle).isString() != null) { |
| valeur = personnel.get(cle).isString().stringValue(); |
| } |
| if (cleObjet.equals("truk_telephone")) { |
| set("telephone", valeur); |
| set("tel_fix", getInfoDenormaliseParType(valeur, Personne.TELEPHONE_FIXE)); |
| set("tel_fax", getInfoDenormaliseParType(valeur, Personne.TELEPHONE_FAX)); |
| } else if (cleObjet.equals("truk_courriel")) { |
| set("courriel", getInfoDenormaliseParPosition(valeur, 1)); |
| } else if (cleObjet.equals("ce_truk_specialite")) { |
| set("specialite", getInfoDenormaliseParPosition(valeur, 1)); |
| } else { |
| set(cleObjet, valeur); |
| } |
| } |
| } |
| } |
| public StructureAPersonne(Personne personne, String fonction, String roleId, String codeEtat) { |
| Map<String, Object> a = personne.getProperties(); |
| Set<String> cles = a.keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| String cleObjet = cle.replaceFirst("^"+Personne.PREFIXE+"_", ""); |
| String valeur = (String)a.get(cle); |
| if (a.get(cle) != null) { |
| if (cle.equals("truk_telephone")) { |
| set("telephone", a.get(cle)); |
| set("tel_fix", getInfoDenormaliseParType(valeur, Personne.TELEPHONE_FIXE)); |
| set("tel_fax", getInfoDenormaliseParType(valeur, Personne.TELEPHONE_FAX)); |
| } else if (cleObjet.equals("truk_courriel")) { |
| set("courriel", getInfoDenormaliseParPosition(valeur, 1)); |
| } else if (cleObjet.equals("ce_truk_specialite")) { |
| set("specialite", getInfoDenormaliseParPosition(valeur, 1)); |
| } else { |
| this.set(cleObjet, a.get(cle)); |
| } |
| } |
| } |
| setFonction(fonction); |
| setIdRole(roleId); |
| // Définition des valeurs par défaut de variables obligatoires vis à vis de l'utilisation de l'objet |
| set("contact", false); |
| set("fonction", fonction); |
| set("statut", ""); |
| set("travail", 0); |
| set("etat", codeEtat); |
| } |
| /** |
| * Constructeur avec la fonction à passer en paramètre |
| * |
| * @param fonction fonction de la personne dans la structure. |
| * @param role identifiant du rôle de la personne vis à vis de la structure. |
| */ |
| public StructureAPersonne(String fonction, String roleId) { |
| setFonction(fonction); |
| setIdRole(roleId); |
| // Définition des valeurs par défaut de variables obligatoires vis à vis de l'utilisation de l'objet |
| set("contact", false); |
| set("fonction", fonction); |
| set("statut", ""); |
| set("travail", 0); |
| } |
| /** |
| * Constructeur avec la fonction à passer en paramètre |
| * |
| * @param fonction fonction de la personne dans la structure. |
| * @param role identifiant du rôle de la personne vis à vis de la structure. |
| */ |
| public StructureAPersonne(String fonction, String roleId, String codeEtat) { |
| setFonction(fonction); |
| setIdRole(roleId); |
| // Définition des valeurs par défaut de variables obligatoires vis à vis de l'utilisation de l'objet |
| set("contact", false); |
| set("fonction", fonction); |
| set("statut", ""); |
| set("travail", 0); |
| set("etat", codeEtat); |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| // ID |
| /** Génère un identifiant de StructureAPersonne. |
| * |
| * C'est une concaténation des clés primaires de la table coel_structure_a_personne séparées par un tiret "-". |
| * |
| * @return identifiant unique d'une relation "structure à personne". |
| */ |
| public String getId() { |
| String idStructure = renvoyerValeurCorrecte("id_structure"); |
| String idPersonne = renvoyerValeurCorrecte("id_personne"); |
| String idRole = renvoyerValeurCorrecte("id_role"); |
| if (idStructure.equals("") && idPersonne.equals("") && idRole.equals("")) { |
| return null; |
| } else { |
| return (idStructure+"-"+idPersonne+"-"+idRole); |
| } |
| } |
| //+---------------------------------------------------------------------------------------------------------------+ |
| // CHAMPS PROVENANT de la TABLE COEL_STRUCTURE_A_PERSONNE |
| // ID STRUCTURE |
| public String getIdStructure() { |
| return renvoyerValeurCorrecte("id_structure"); |
| } |
| public void setIdStructure(String is) { |
| set("id_structure", is); |
| } |
| // ID PERSONNE |
| public String getIdPersonne() { |
| return renvoyerValeurCorrecte("id_personne"); |
| } |
| public void setIdPersonne(String ip) { |
| set("id_personne", ip); |
| } |
| // ID RôLE |
| public String getIdRole() { |
| return renvoyerValeurCorrecte("id_role"); |
| } |
| public void setIdRole(String ir) { |
| set("id_role", ir); |
| } |
| // FONCTION |
| public String getFonction() { |
| return renvoyerValeurCorrecte("ce_truk_fonction"); |
| } |
| public void setFonction(String ctf) { |
| set("ce_truk_fonction", ctf); |
| } |
| public void setFonction(String type, String valeur) { |
| setChaineDenormaliseUnique("ce_truk_fonction", type, valeur); |
| } |
| // SERVICE |
| public String getService() { |
| return renvoyerValeurCorrecte("service"); |
| } |
| public void setService(String s) { |
| set("service", s); |
| } |
| // STATUT |
| public String getStatut() { |
| return renvoyerValeurCorrecte("ce_truk_statut"); |
| } |
| public void setStatut(String cts) { |
| set("ce_truk_statut", cts); |
| } |
| public void setStatut(String type, String valeur) { |
| setChaineDenormaliseUnique("ce_truk_statut", type, valeur); |
| } |
| // CONTACT |
| public String getContact() { |
| return renvoyerValeurCorrecte("mark_contact"); |
| } |
| public void setContact(String c) { |
| //set("contact", (c.equals("1") ? true : false)); |
| set("mark_contact", c); |
| } |
| public void setContact(Boolean c) { |
| setContact((c.equals(Boolean.TRUE) ? "1" : "0")); |
| } |
| // BOTA TRAVAIL HEBDO TPS |
| public String getBotaTravailHebdoTps() { |
| return renvoyerValeurCorrecte("bota_travail_hebdo_tps"); |
| } |
| public void setBotaTravailHebdoTps(String btht) { |
| set("bota_travail_hebdo_tps", btht); |
| } |
| //+---------------------------------------------------------------------------------------------------------------+ |
| // CHAMPS PROVENANT de la TABLE COEL_PERSONNE |
| // ID PROJET PERSONNE |
| public String getIdProjetPersonne() { |
| return renvoyerValeurCorrecte("ce_projet"); |
| } |
| public void setIdProjetPersonne(String ipp) { |
| set("ce_projet", ipp); |
| } |
| // PRÉNOM |
| public String getPrenom() { |
| return renvoyerValeurCorrecte("prenom"); |
| } |
| public void setPrenom(String prenom) { |
| set("prenom", prenom); |
| } |
| // NOM |
| public String getNom() { |
| return renvoyerValeurCorrecte("nom"); |
| } |
| public void setNom(String nom) { |
| set("nom", nom); |
| } |
| // NOM COMPLET |
| public String getNomComplet() { |
| return renvoyerValeurCorrecte("fmt_nom_complet"); |
| } |
| public void setNomComplet(String nomComplet) { |
| set("fmt_nom_complet", nomComplet); |
| } |
| // TÉLÉPHONE |
| public String getTelephone() { |
| return renvoyerValeurCorrecte("telephone"); |
| } |
| public void setTelephone(String tel) { |
| set("telephone", tel); |
| } |
| // TÉLÉPHONE FIXE |
| public String getTelephoneFixe() { |
| return getInfoDenormaliseParType(renvoyerValeurCorrecte("telephone"), Personne.TELEPHONE_FIXE); |
| } |
| public void setTelephoneFixe(String fixe) { |
| // Nous remplaçons le premier numéro de Téléphone FIXE de la personne |
| modifierChaineDenormaliseParType("telephone", Personne.TELEPHONE_FIXE, fixe); |
| } |
| // TÉLÉPHONE FAX |
| public String getFax() { |
| return getInfoDenormaliseParType(renvoyerValeurCorrecte("telephone"), Personne.TELEPHONE_FAX); |
| } |
| public void setFax(String fax) { |
| // Nous remplaçons le premier numéro de FAX de la personne |
| modifierChaineDenormaliseParType("telephone", Personne.TELEPHONE_FAX, fax); |
| } |
| // COURRIEL |
| public String getCourriel() { |
| return renvoyerValeurCorrecte("courriel"); |
| } |
| public void setCourriel(String courriel) { |
| // Nous remplaçons le courriel en position 1 (principal) |
| this.modifierChaineDenormaliseParPosition("courriel", 1, courriel); |
| } |
| public String selectionnerCourriel(int position) { |
| return getInfoDenormaliseParPosition(renvoyerValeurCorrecte("courriel"), position); |
| } |
| // SPÉCIALITÉ |
| public String getSpecialite() { |
| return renvoyerValeurCorrecte("specialite"); |
| } |
| public void setSpecialite(String specialite) { |
| setChaineDenormaliseUnique("specialite", "AUTRE", specialite); |
| } |
| public String afficherSpecialite() { |
| return getChaineDenormaliseUnique("specialite"); |
| } |
| public String getDeces() { |
| return renvoyerValeurCorrecte("ce_deces"); |
| } |
| public void setDeces(String etat) { |
| set("ce_deces", etat); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/StructureAPersonne.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/structure/StructureConservation.java |
|---|
| New file |
| 0,0 → 1,236 |
| package org.tela_botanica.client.modeles.structure; |
| import java.util.Iterator; |
| import java.util.Set; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import com.google.gwt.json.client.JSONObject; |
| public class StructureConservation extends aDonnee { |
| private static final long serialVersionUID = -4556005804101933910L; |
| public static final String PREFIXE = "csc"; |
| public static String[] champsObligatoires = {"csc_id_structure"}; |
| public StructureConservation() { |
| } |
| public StructureConservation(JSONObject conservation) { |
| // L'objet JSON est une table de hachage |
| Set<String> im = conservation.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| if (cle.startsWith(PREFIXE+"_")) { |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = ""; |
| if (conservation.get(cle).isString() != null) { |
| valeur = conservation.get(cle).isString().stringValue(); |
| } |
| this.set(cleObjet, valeur); |
| } |
| } |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| // FORMATION |
| public String getFormation() { |
| return renvoyerValeurCorrecte("mark_formation"); |
| } |
| public void setFormation(String f) { |
| this.set("mark_formation", f); |
| } |
| // FORMATION INFO |
| public String getFormationInfo() { |
| return renvoyerValeurCorrecte("formation"); |
| } |
| public void setFormationInfo(String f) { |
| this.set("formation", f); |
| } |
| // FORMATION INTÉRÊT |
| public String getFormationInteret() { |
| return renvoyerValeurCorrecte("mark_formation_interet"); |
| } |
| public void setFormationInteret(String f) { |
| this.set("mark_formation_interet", f); |
| } |
| // STOCKAGE LOCAL |
| public String getStockageLocal() { |
| return renvoyerValeurCorrecte("truk_stockage_local"); |
| } |
| public void setStockageLocal(String sl) { |
| this.set("truk_stockage_local", sl); |
| } |
| public void setStockageLocal(String type, Object valeur) { |
| remplacerTypeDansChaineDenormalise("truk_stockage_local", type, valeur); |
| } |
| // STOCKAGE MEUBLE |
| public String getStockageMeuble() { |
| return renvoyerValeurCorrecte("truk_stockage_meuble"); |
| } |
| public void setStockageMeuble(String sm) { |
| this.set("truk_stockage_meuble", sm); |
| } |
| public void setStockageMeuble(String type, Object valeur) { |
| remplacerTypeDansChaineDenormalise("truk_stockage_meuble", type, valeur); |
| } |
| // STOCKAGE PARAMÊTRE |
| public String getStockageParametre() { |
| return renvoyerValeurCorrecte("truk_stockage_parametre"); |
| } |
| public void setStockageParametre(String sl) { |
| this.set("truk_stockage_parametre", sl); |
| } |
| public void setStockageParametre(String type, Object valeur) { |
| remplacerTypeDansChaineDenormalise("truk_stockage_parametre", type, valeur); |
| } |
| // COLLECTION COMMUNE |
| public String getCollectionCommune() { |
| return renvoyerValeurCorrecte("mark_collection_commune"); |
| } |
| public void setCollectionCommune(String ccm) { |
| this.set("mark_collection_commune", ccm); |
| } |
| // COLLECTION AUTRE |
| public String getCollectionAutre() { |
| return renvoyerValeurCorrecte("truk_collection_autre"); |
| } |
| public void setCollectionAutre(String ca) { |
| this.set("truk_collection_autre", ca); |
| } |
| public void setCollectionAutre(String type, Object valeur) { |
| remplacerTypeDansChaineDenormalise("truk_collection_autre", type, valeur); |
| } |
| // ACCÈS CONTROLÉ |
| public String getAccesControle() { |
| return renvoyerValeurCorrecte("mark_acces_controle"); |
| } |
| public void setAccesControle(String ac) { |
| this.set("mark_acces_controle", ac); |
| } |
| // RESTAURATION |
| public String getRestauration() { |
| return renvoyerValeurCorrecte("mark_restauration"); |
| } |
| public void setRestauration(String ccm) { |
| this.set("mark_restauration", ccm); |
| } |
| // RESTAURATION OPÉRATION |
| public String getRestaurationOperation() { |
| return renvoyerValeurCorrecte("truk_restauration_operation"); |
| } |
| public void setRestaurationOperation(String ro) { |
| this.set("truk_restauration_operation", ro); |
| } |
| public void setRestaurationOperation(String type, Object valeur) { |
| ajouterChaineDenormaliseAvecType("truk_restauration_operation", type, valeur); |
| } |
| // MATERIEL CONSERVATION |
| public String getMaterielConservation() { |
| return renvoyerValeurCorrecte("ce_materiel_conservation"); |
| } |
| public void setMaterielConservation(String mc) { |
| this.set("ce_materiel_conservation", mc); |
| } |
| // MATERIEL AUTRE |
| public String getMaterielAutre() { |
| return renvoyerValeurCorrecte("truk_materiel_autre"); |
| } |
| public void setMaterielAutre(String ma) { |
| this.set("truk_materiel_autre", ma); |
| } |
| public void setMaterielAutre(String type, Object valeur) { |
| ajouterChaineDenormaliseAvecType("truk_materiel_autre", type, valeur); |
| } |
| // TRAITEMENT |
| public String getTraitement() { |
| return renvoyerValeurCorrecte("mark_traitement"); |
| } |
| public void setTraitement(String t) { |
| this.set("mark_traitement", t); |
| } |
| // TRAITEMENTS |
| public String getTraitements() { |
| return renvoyerValeurCorrecte("truk_traitement"); |
| } |
| public void setTraitements(String t) { |
| this.set("truk_traitement", t); |
| } |
| public void setTraitements(String type, Object valeur) { |
| ajouterChaineDenormaliseAvecType("truk_traitement", type, valeur); |
| } |
| // ACQUISITION COLLECTION |
| public String getAcquisitionCollection() { |
| return renvoyerValeurCorrecte("mark_acquisition_collection"); |
| } |
| public void setAcquisitionCollection(String ac) { |
| this.set("mark_acquisition_collection", ac); |
| } |
| // ACQUISITION ECHANTILLON |
| public String getAcquisitionEchantillon() { |
| return renvoyerValeurCorrecte("mark_acquisition_echantillon"); |
| } |
| public void setAcquisitionEchantillon(String ae) { |
| this.set("mark_acquisition_echantillon", ae); |
| } |
| // ACQUISITION TRAITEMENT |
| public String getAcquisitionTraitement() { |
| return renvoyerValeurCorrecte("mark_acquisition_traitement"); |
| } |
| public void setAcquisitionTraitement(String at) { |
| this.set("mark_acquisition_traitement", at); |
| } |
| // ACQUISITION TRAITEMENT POISON |
| public String getAcquisitionTraitementPoison() { |
| return renvoyerValeurCorrecte("truk_acquisition_traitement_poison"); |
| } |
| public void setAcquisitionTraitementPoison(String atp) { |
| this.set("truk_acquisition_traitement_poison", atp); |
| } |
| public void setAcquisitionTraitementPoison(String type, Object valeur) { |
| ajouterChaineDenormaliseAvecType("truk_acquisition_traitement_poison", type, valeur); |
| } |
| // ACQUISITION TRAITEMENT INSECTE |
| public String getAcquisitionTraitementInsecte() { |
| return renvoyerValeurCorrecte("truk_acquisition_traitement_insecte"); |
| } |
| public void setAcquisitionTraitementInsecte(String ati) { |
| this.set("truk_acquisition_traitement_insecte", ati); |
| } |
| public void setAcquisitionTraitementInsecte(String type, Object valeur) { |
| ajouterChaineDenormaliseAvecType("truk_acquisition_traitement_insecte", type, valeur); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/StructureConservation.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/structure/StructureValorisation.java |
|---|
| New file |
| 0,0 → 1,167 |
| package org.tela_botanica.client.modeles.structure; |
| import java.util.Iterator; |
| import java.util.Set; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import com.google.gwt.json.client.JSONObject; |
| public class StructureValorisation extends aDonnee { |
| private static final long serialVersionUID = 8906713360999774621L; |
| public static final String PREFIXE = "csv"; |
| public static String[] champsObligatoires = {"csv_id_structure"}; |
| public StructureValorisation() { |
| } |
| public StructureValorisation(JSONObject valorisation) { |
| // L'objet JSON est une table de hachage |
| Set<String> im = valorisation.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| if (cle.startsWith(PREFIXE+"_")) { |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = ""; |
| if (valorisation.get(cle).isString() != null) { |
| valeur = valorisation.get(cle).isString().stringValue(); |
| } |
| this.set(cleObjet, valeur); |
| } |
| } |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| // ACTION |
| public String getAction() { |
| return renvoyerValeurCorrecte("mark_action"); |
| } |
| public void setAction(String a) { |
| this.set("mark_action", a); |
| } |
| // ACTION INFO |
| public String getActionInfo() { |
| return renvoyerValeurCorrecte("truk_action"); |
| } |
| public void setActionInfo(String a) { |
| this.set("truk_action", a); |
| } |
| public void setActionInfo(String type, Object valeur) { |
| remplacerTypeDansChaineDenormalise("truk_action", type, valeur); |
| } |
| // PUBLICATION |
| public String getPublication() { |
| return renvoyerValeurCorrecte("publication"); |
| } |
| public void setPublication(String p) { |
| this.set("publication", p); |
| } |
| // COLLECTION AUTRE |
| public String getCollectionAutre() { |
| return renvoyerValeurCorrecte("collection_autre"); |
| } |
| public void setCollectionAutre(String ca) { |
| this.set("collection_autre", ca); |
| } |
| public void setCollectionAutre(String type, Object valeur) { |
| remplacerTypeDansChaineDenormalise("collection_autre", type, valeur); |
| } |
| // ACTION FUTURE |
| public String getActionFuture() { |
| return renvoyerValeurCorrecte("mark_action_future"); |
| } |
| public void setActionFuture(String af) { |
| this.set("mark_action_future", af); |
| } |
| // ACTION FUTURE INFO |
| public String getActionFutureInfo() { |
| return renvoyerValeurCorrecte("action_future"); |
| } |
| public void setActionFutureInfo(String af) { |
| this.set("action_future", af); |
| } |
| // RECHERCHE |
| public String getRecherche() { |
| return renvoyerValeurCorrecte("mark_recherche"); |
| } |
| public void setRecherche(String r) { |
| this.set("mark_recherche", r); |
| } |
| // RECHERCHE PROVENANCE |
| public String getRechercheProvenance() { |
| return renvoyerValeurCorrecte("truk_recherche_provenance"); |
| } |
| public void setRechercheProvenance(String rp) { |
| this.set("truk_recherche_provenance", rp); |
| } |
| public void setRechercheProvenance(String type, Object valeur) { |
| remplacerTypeDansChaineDenormalise("truk_recherche_provenance", type, valeur); |
| } |
| // RECHERCHE TYPE |
| public String getRechercheType() { |
| return renvoyerValeurCorrecte("truk_recherche_type"); |
| } |
| public void setRechercheType(String rt) { |
| this.set("truk_recherche_type", rt); |
| } |
| public void setRechercheType(String type, Object valeur) { |
| remplacerTypeDansChaineDenormalise("truk_recherche_type", type, valeur); |
| } |
| // ACCES SANS MOTIF |
| public String getAccesSansMotif() { |
| return renvoyerValeurCorrecte("mark_acces_ss_motif"); |
| } |
| public void setAccesSansMotif(String asm) { |
| this.set("mark_acces_ss_motif", asm); |
| } |
| // ACCES SANS MOTIF INFO |
| public String getAccesSansMotifInfo() { |
| return renvoyerValeurCorrecte("acces_ss_motif"); |
| } |
| public void setAccesSansMotifInfo(String asm) { |
| this.set("acces_ss_motif", asm); |
| } |
| // VISITE AVEC MOTIF |
| public String getVisiteAvecMotif() { |
| return renvoyerValeurCorrecte("mark_visite_avec_motif"); |
| } |
| public void setVisiteAvecMotif(String vam) { |
| this.set("mark_visite_avec_motif", vam); |
| } |
| // VISITE AVEC MOTIF INFO |
| public String getVisiteAvecMotifInfo() { |
| return renvoyerValeurCorrecte("visite_avec_motif"); |
| } |
| public void setVisiteAvecMotifInfo(String vam) { |
| this.set("visite_avec_motif", vam); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/StructureValorisation.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/structure/StructureAPersonneListe.java |
|---|
| New file |
| 0,0 → 1,41 |
| package org.tela_botanica.client.modeles.structure; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Table de hachage composée d'informations sur les Structures et les Personnes, renvoyé par un objet de type DAO |
| * La clé est une concaténation des clés primaires de la table coel_structure_a_personne séparées par un tiret "-". |
| * |
| * @author david delon |
| * |
| */ |
| public class StructureAPersonneListe extends aDonneeListe<StructureAPersonne> { |
| private static final long serialVersionUID = -2000442795474013672L; |
| public StructureAPersonneListe() { |
| super(); |
| } |
| public StructureAPersonneListe(int taille) { |
| super(taille); |
| } |
| public StructureAPersonneListe(JSONArray structures) { |
| super(structures.size()) ; |
| final int taillemax = structures.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject structureAPersonneCourante = structures.get(i).isObject() ; |
| if (structureAPersonneCourante != null) { |
| StructureAPersonne structureAPersonne = new StructureAPersonne(structureAPersonneCourante); |
| this.put(structureAPersonne.getId(), structureAPersonne); |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/StructureAPersonneListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/structure/StructureAPersonneAsyncDao.java |
|---|
| New file |
| 0,0 → 1,147 |
| package org.tela_botanica.client.modeles.structure; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONValue; |
| public class StructureAPersonneAsyncDao { |
| private static final String SERVICE_NOM = "CoelStructureAPersonne"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public StructureAPersonneAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| StructureAPersonneAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante; |
| utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId(); |
| } |
| public void selectionner(final String structureId, final String roleId, final Integer seqId) { |
| String[] parametres = {structureId, roleId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| Information info = new Information("liste_structure_a_personne"); |
| if (responseValue != null) { |
| // Si la requête est un succès, reception d'un tableau |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // Transformation du tableau JSON réponse en ListeInstitution |
| StructureAPersonneListe personnel = new StructureAPersonneListe(reponse); |
| info.setDonnee(0, personnel); |
| // et on met à jour le demandeur des données |
| if (seqId !=null) { |
| Reponse reponseSequenceur = new Reponse(info, seqId); |
| vueARafraichir.rafraichir(reponseSequenceur); |
| } else { |
| vueARafraichir.rafraichir(info); |
| } |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas un talbeau JSON et vaut : "+responseValue.toString(), null); |
| } |
| } else { |
| if (structureId == null) { |
| // Dans le cas, où nous demandons toutes les relations Structure à Personne et qu'il n'y en a pas, nous retournons un message d'information |
| info.setMessage("Aucun personnel"); |
| vueARafraichir.rafraichir(info); |
| } |
| } |
| } |
| }); |
| } |
| public void ajouter(String structureId, StructureAPersonne personnel) { |
| String postDonneesEncodees = construirePost(structureId, personnel); |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| Information info = new Information("ajout_structure_a_personne"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void modifier(StructureAPersonne personnel) { |
| String[] parametres = {personnel.getIdStructure(), personnel.getIdPersonne(), personnel.getIdRole()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| String postDonneesEncodees = construirePost(personnel.getIdStructure(), personnel); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| Information info = new Information("modif_structure_a_personne"); |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void supprimer(String idStrAPer) { |
| String[] parametres = {utilisateurId, idStrAPer}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("suppression_structure_a_personne"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| private String construirePost(String structureId, StructureAPersonne personnel) { |
| String postDonnees = "cmhl_ce_modifier_par=" + URL.encodeComponent(utilisateurId); |
| if (!personnel.getIdPersonne().equals("")) { |
| postDonnees += "&csap_id_personne=" + URL.encodeComponent(personnel.getIdPersonne()) + |
| "&cp_id_personne=" + URL.encodeComponent(personnel.getIdPersonne()); |
| } |
| postDonnees += "&csap_id_structure=" + URL.encodeComponent(structureId) + |
| "&csap_id_role=" + URL.encodeComponent(personnel.getIdRole()) + |
| "&csap_ce_truk_fonction=" + URL.encodeComponent(personnel.getFonction()) + |
| "&csap_service=" + URL.encodeComponent(personnel.getService()) + |
| "&csap_ce_truk_statut=" + URL.encodeComponent(personnel.getStatut()) + |
| "&csap_mark_contact=" + URL.encodeComponent(personnel.getContact()) + |
| "&csap_bota_travail_hebdo_tps=" + URL.encodeComponent(personnel.getBotaTravailHebdoTps()) + |
| "&cp_ce_projet=" + URL.encodeComponent(personnel.getIdProjetPersonne()) + |
| "&cp_prenom=" + URL.encodeComponent(personnel.getPrenom()) + |
| "&cp_nom=" + URL.encodeComponent(personnel.getNom()) + |
| "&cp_fmt_nom_complet=" + URL.encodeComponent(personnel.getNomComplet()) + |
| "&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; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/StructureAPersonneAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/structure/Structure.java |
|---|
| New file |
| 0,0 → 1,416 |
| package org.tela_botanica.client.modeles.structure; |
| import java.util.Date; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import org.tela_botanica.client.modeles.personne.Personne; |
| 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; |
| public class Structure extends aDonnee { |
| private static final long serialVersionUID = -5623886668593288218L; |
| public static final String PREFIXE = "cs"; |
| public static final String URL_SITE = "WEB"; |
| public static final String URL_LOGO = "LOGO"; |
| private BaseModelData urls = null; |
| private StructureAPersonneListe personnel = null; |
| private StructureValorisation valorisation = null; |
| private StructureConservation conservation = null; |
| public static String[] champsObligatoires = {"cs_id_structure", "csc_id_structure", "csv_id_structure"}; |
| public Structure() { |
| // Constructions du tableau des urls interne |
| urls = new BaseModelData(); |
| } |
| public Structure(ModelData model) |
| { |
| Map<String, Object> a = model.getProperties(); |
| Set<String> cles = a.keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| if (a.get(cle) != null) { |
| String cleObjet = cle.replaceFirst("^"+getPrefixe()+"_", ""); |
| this.set(cleObjet, a.get(cle)); |
| } |
| } |
| } |
| public Structure(JSONObject institution) { |
| // Constructions du tableau des urls interne |
| urls = new BaseModelData(); |
| // l'objet JSON est une table de hachage |
| Set<String> im = institution.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| if (cle.startsWith(PREFIXE+"_")) { |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = ""; |
| if (institution.get(cle).isString() != null) { |
| valeur = institution.get(cle).isString().stringValue(); |
| } |
| if (cleObjet.equals("truk_url")) { |
| this.setUrl(valeur); |
| } else { |
| this.set(cleObjet, valeur); |
| } |
| } |
| } |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| public String getId() { |
| return renvoyerValeurCorrecte("id_structure"); |
| } |
| public void setId(String idStructure) { |
| this.set("id_structure", idStructure); |
| } |
| public String getIdProjet() { |
| return renvoyerValeurCorrecte("ce_projet"); |
| } |
| public void setIdProjet(String idProjet) { |
| this.set("ce_projet", idProjet); |
| } |
| public String getIdMere() { |
| return renvoyerValeurCorrecte("ce_mere"); |
| } |
| public void setIdMere(String idMere) { |
| this.set("ce_mere", idMere); |
| } |
| public String getGuid() { |
| return renvoyerValeurCorrecte("guid"); |
| } |
| public void setGuid(String guid) { |
| this.set("guid", guid); |
| } |
| public String getIdAlternatif() { |
| return renvoyerValeurCorrecte("truk_identifiant_alternatif"); |
| } |
| public void setIdAlternatif(String idAlter) { |
| this.set("truk_identifiant_alternatif", idAlter); |
| } |
| public String getNom() { |
| return renvoyerValeurCorrecte("nom"); |
| } |
| public void setNom(String nom) { |
| this.set("nom", nom); |
| } |
| public String getNomAlternatif() { |
| return renvoyerValeurCorrecte("truk_nom_alternatif"); |
| } |
| public String getDescription() { |
| return renvoyerValeurCorrecte("description"); |
| } |
| public void setDescription(String description) { |
| this.set("description", description); |
| } |
| public String getType() { |
| return renvoyerValeurCorrecte("ce_type"); |
| } |
| public void setType(String type) { |
| this.set("ce_type", type); |
| } |
| public String getTypePrive() { |
| return renvoyerValeurCorrecte("ce_truk_type_prive"); |
| } |
| public void setTypePrive(String typePrive) { |
| this.set("ce_truk_type_prive", typePrive); |
| } |
| public String getTypePublic() { |
| return renvoyerValeurCorrecte("ce_truk_type_public"); |
| } |
| public void setTypePublic(String typePublic) { |
| this.set("ce_truk_type_public", typePublic); |
| } |
| public String getAbreviationProjet() { |
| return renvoyerValeurCorrecte("_abreviationprojet_"); |
| } |
| public void setAbreviationProjet(String abreviation) { |
| this.set("_abreviationprojet_", abreviation); |
| } |
| public String getAdresse() { |
| return (String) renvoyerValeurCorrecte("adresse_01"); |
| } |
| public void setAdresse(String adr) { |
| this.set("adresse_01", adr); |
| } |
| public String getAdresseComplement() { |
| return renvoyerValeurCorrecte("adresse_02"); |
| } |
| public void setAdresseComplement(String adr) { |
| this.set("adresse_02", adr); |
| } |
| public String getDateFondationFormatMysql() { |
| return renvoyerValeurCorrecte("date_fondation"); |
| } |
| public String getDateFondationFormatLong() { |
| String dateFormatee = ""; |
| Date dateFondation = getDateFondation(); |
| if (dateFondation != null) { |
| dateFormatee = DateTimeFormat.getLongDateFormat().format(dateFondation); |
| } |
| return dateFormatee; |
| } |
| public String getAnneOuDateFondationFormatLong() { |
| String dateFormatee = ""; |
| String dateFondation = renvoyerValeurCorrecte("date_fondation"); |
| if (!dateFondation.equals("")) { |
| if (dateFondation.endsWith("00-00")) { |
| dateFormatee = dateFondation.substring(0, 4); |
| } else { |
| Date date = DateTimeFormat.getFormat("yyyy-MM-dd").parse(dateFondation); |
| dateFormatee = DateTimeFormat.getLongDateFormat().format(date); |
| } |
| } |
| return dateFormatee; |
| } |
| public Date getDateFondation() { |
| Date fondationDate = null; |
| String fondationChaine = renvoyerValeurCorrecte("date_fondation"); |
| if (!fondationChaine.isEmpty() && !fondationChaine.equals("0000-00-00")) { |
| fondationDate = DateTimeFormat.getFormat("yyyy-MM-dd").parseStrict(fondationChaine); |
| } |
| return fondationDate; |
| } |
| public String getAnneeOuDateFondation() { |
| String valeurDateFondation = get("date_fondation"); |
| if (!UtilString.isEmpty(valeurDateFondation) && valeurDateFondation.endsWith("00-00")) { |
| valeurDateFondation = valeurDateFondation.substring(0, 4); |
| } else if (UtilString.isEmpty(valeurDateFondation) && valeurDateFondation.equals("0000-00-00")) { |
| valeurDateFondation = ""; |
| } |
| return valeurDateFondation; |
| } |
| public void setDateFondation(Date dateFondation) { |
| if (dateFondation != null) { |
| this.set("date_fondation", DateTimeFormat.getFormat("yyyy-MM-dd").format(dateFondation)); |
| } |
| } |
| public void setDateFondation(String dateFondation) { |
| if (dateFondation != null) { |
| this.set("date_fondation", dateFondation); |
| } |
| } |
| public String getCodePostal() { |
| return renvoyerValeurCorrecte("code_postal"); |
| } |
| public void setCodePostal(String codePostal) { |
| this.set("code_postal", codePostal); |
| } |
| public String getVille() { |
| return renvoyerValeurCorrecte("ville"); |
| } |
| public void setVille(String ville) { |
| this.set("ville", ville); |
| } |
| public String getRegion() { |
| return getChaineDenormaliseUnique("ce_truk_region"); |
| } |
| public void setRegion(String region) { |
| this.set("ce_truk_region", region); |
| } |
| public String getPays() { |
| return getChaineDenormaliseUnique("ce_truk_pays"); |
| } |
| public void setPays(String pays) { |
| this.set("ce_truk_pays", pays); |
| } |
| public String getLatitude() { |
| return renvoyerValeurCorrecte("latitude"); |
| } |
| public void setLatitude(String latitude) { |
| if (latitude != null) { |
| latitude = latitude.replace(".", ","); |
| } |
| this.set("latitude", latitude); |
| } |
| public String getLongitude() { |
| return renvoyerValeurCorrecte("longitude"); |
| } |
| public void setLongitude(String longitude) { |
| if (longitude != null) { |
| longitude = longitude.replace(".", ","); |
| } |
| this.set("longitude", longitude); |
| } |
| // TELEPHONE |
| public String getTelephone() { |
| return renvoyerValeurCorrecte("truk_telephone"); |
| } |
| public void setTelephone(String tel) { |
| this.set("truk_telephone", tel); |
| } |
| // TELEPHONE FIXE |
| public String getTelephoneFixe() { |
| return getInfoDenormaliseParType(renvoyerValeurCorrecte("truk_telephone"), Personne.TELEPHONE_FIXE); |
| } |
| public void setTelephoneFixe(String fixe) { |
| modifierChaineDenormaliseParType("truk_telephone", Personne.TELEPHONE_FIXE, fixe); |
| } |
| //TELEPHONE FAX |
| public String getFax() { |
| return getInfoDenormaliseParType(renvoyerValeurCorrecte("truk_telephone"), Personne.TELEPHONE_FAX); |
| } |
| public void setFax(String fax) { |
| modifierChaineDenormaliseParType("truk_telephone", Personne.TELEPHONE_FAX, fax); |
| } |
| // COURRIEL |
| public String getCourriel() { |
| return renvoyerValeurCorrecte("courriel"); |
| } |
| public void setCourriel(String courriel) { |
| this.set("courriel", courriel); |
| } |
| // URL |
| public String getUrl(String type) { |
| return urls.get(type); |
| } |
| public String getUrl() { |
| String urlsDenormalise = ""; |
| Set<String> proprietes = urls.getProperties().keySet(); |
| for (Iterator<String> it = proprietes.iterator(); it.hasNext();) { |
| String cle = it.next(); |
| urlsDenormalise += cle+"##"+urls.get(cle)+";;"; |
| } |
| urlsDenormalise = urlsDenormalise.replaceFirst(";;$", ""); |
| return urlsDenormalise; |
| } |
| public void setUrl(String urlsDenormalise) { |
| if (urlsDenormalise != null && !urlsDenormalise.equals("")) { |
| //GWT.log(urlsDenormalise, null); |
| String[] tableauUrls = urlsDenormalise.split(";;"); |
| for (int i = 0; i < tableauUrls.length; i++) { |
| String url = tableauUrls[i]; |
| //GWT.log("\t"+url, null); |
| String[] tableauUrl = url.split("##"); |
| if (tableauUrl.length == 2) { |
| //GWT.log("\t\t"+tableauUrl[0]+"-"+tableauUrl[1], null); |
| urls.set(tableauUrl[0], tableauUrl[1]); |
| } |
| } |
| } |
| } |
| public void setUrl(String type, String url) { |
| if (url != null) { |
| urls.set(type, url); |
| } |
| } |
| public int getNbrePersonne() { |
| if (renvoyerValeurCorrecte("nbre_personne").equals("")) { |
| return 0; |
| } else { |
| return Integer.parseInt(renvoyerValeurCorrecte("nbre_personne")); |
| } |
| } |
| public void setNbrePersonne(int nbrePersonne) { |
| this.set("nbre_personne", Integer.toString(nbrePersonne)); |
| } |
| public String getConditionAcces() { |
| return renvoyerValeurCorrecte("condition_acces"); |
| } |
| public void setConditionAcces(String acces) { |
| this.set("condition_acces", acces); |
| } |
| public String getConditionUsage() { |
| return renvoyerValeurCorrecte("condition_usage"); |
| } |
| public void setConditionUsage(String usage) { |
| this.set("condition_usage", usage); |
| } |
| public StructureAPersonneListe getPersonnel() { |
| return personnel; |
| } |
| public void setPersonnel(StructureAPersonneListe personnelAStocker) { |
| personnel = personnelAStocker; |
| } |
| public StructureValorisation getValorisation() { |
| return valorisation; |
| } |
| public void setValorisation(StructureValorisation valorisationAStocker) { |
| valorisation = valorisationAStocker; |
| } |
| public StructureConservation getConservation() { |
| return conservation; |
| } |
| public void setConservation(StructureConservation conservationAStocker) { |
| conservation = conservationAStocker; |
| } |
| public String toString() { |
| String sortie = ""; |
| // Champs du BaseModelData |
| Set<String> proprietes = this.getProperties().keySet(); |
| for (Iterator<String> it = proprietes.iterator(); it.hasNext();) { |
| String cle = it.next(); |
| sortie += cle+" : "+this.get(cle)+"\n"; |
| } |
| // Champs spéciaux |
| sortie += getUrl(); |
| return sortie; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/Structure.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/structure/StructureListe.java |
|---|
| New file |
| 0,0 → 1,128 |
| package org.tela_botanica.client.modeles.structure; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.i18n.client.Dictionary; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Classe contenant les informations sur les Structures renvoyées par un objet de type DAO. |
| * |
| * @author Jean-Pascal MILCENT |
| * |
| */ |
| public class StructureListe extends aDonneeListe<Structure> implements ListePaginable { |
| private static final long serialVersionUID = 7384579567038300856L; |
| private int currentPage = 0; |
| private int nbElementsPage = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); |
| private int nbElementsTotal; |
| private Rafraichissable vueARafraichir; |
| public StructureListe() { |
| super(); |
| } |
| public StructureListe(int taille) { |
| super(taille); |
| } |
| public StructureListe(JSONArray ListeDeStructures) { |
| super(ListeDeStructures.size()) ; |
| initialiserStructureListe(ListeDeStructures); |
| } |
| public StructureListe(JSONArray ListeDeStructures, JSONNumber nbElements, Rafraichissable vueARafraichir) { |
| super(ListeDeStructures.size()); |
| this.nbElementsTotal = Integer.valueOf(nbElements.toString()); |
| this.vueARafraichir = vueARafraichir; |
| initialiserStructureListe(ListeDeStructures); |
| } |
| private void initialiserStructureListe(JSONArray ListeDeStructures) { |
| final int taillemax = ListeDeStructures.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject structureCourante = ListeDeStructures.get(i).isObject(); |
| if (structureCourante != null) { |
| Structure structure = new Structure(structureCourante); |
| StructureValorisation valorisation = new StructureValorisation(structureCourante); |
| structure.setValorisation(valorisation); |
| StructureConservation conservation = new StructureConservation(structureCourante); |
| structure.setConservation(conservation); |
| this.put(structure.getId(), structure); |
| } |
| } |
| } |
| public void changerNumeroPage(int pageCourante) { |
| currentPage = pageCourante; |
| selectionnerStructure(); |
| } |
| public void changerTaillePage(int nouvelleTaillePage) { |
| nbElementsPage = nouvelleTaillePage; |
| selectionnerStructure(); |
| } |
| public void recharger() { |
| selectionnerStructure(); |
| } |
| public void setPageCourante(int pageCourante) { |
| this.currentPage = pageCourante; |
| } |
| public void setTaillePage(int taillePage) { |
| this.nbElementsPage = taillePage; |
| } |
| public int[] getPageTable() { |
| int[] page = new int[4]; |
| // Nombre de pages au total |
| page[0] = calculerNbPages(); |
| // Page En Cours |
| page[1] = currentPage; |
| // nbElementsParPage |
| page[2] = nbElementsPage; |
| // et le dernier le nombre total d'éléments |
| page[3] = nbElementsTotal; |
| return page; |
| } |
| /** |
| * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements |
| * donnés en fonction de la taille de page en cours |
| * |
| * @return le nombre de pages |
| */ |
| public int calculerNbPages() { |
| // À cause de la bétise de java pour les conversion implicite, on fait quelques conversions manuellement |
| // pour eviter qu'il arrondisse mal la division nombre de pages = (nombre d'element / taille de la page) |
| // arrondie à l'entier supérieur. |
| double nPage = (1.0 * nbElementsTotal) / (1.0 * nbElementsPage); |
| double nPageRound = Math.ceil(nPage); |
| Double nPageInt = new Double(nPageRound); |
| // Convertion en entier |
| return nPageInt.intValue(); |
| } |
| public void selectionnerStructure() { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerStructure(vueARafraichir, null, mediateur.getProjetId(), null, currentPage, nbElementsPage, null); |
| } |
| public void filtrerParNom(String nom) { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerStructure(vueARafraichir, mediateur.getProjetId(), null, "%" + nom + "%", 0, nbElementsPage, null); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/StructureListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/structure/StructureAsyncDao.java |
|---|
| New file |
| 0,0 → 1,291 |
| package org.tela_botanica.client.modeles.structure; |
| import java.util.HashMap; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.personne.PersonneListe; |
| import org.tela_botanica.client.modeles.projet.ProjetListe; |
| import org.tela_botanica.client.synchronisation.Reponse; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONValue; |
| public class StructureAsyncDao { |
| private static final String SERVICE_NOM = "CoelStructure"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public StructureAsyncDao(Rafraichissable vue) { |
| if (Mediateur.DEBUG) System.out.println("|| StructureAsyncDao > vueARafraichir = "+vue.getClass().toString()); |
| 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, 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("orderby", "cs_ville"); |
| if (nbElements != -1) { |
| restrictions.put("limit", String.valueOf(nbElements)); |
| } |
| /** 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) |
| { |
| 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) { |
| 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); |
| } |
| } 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); |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("ajout_structure"); |
| String structureIdOuMessage = responseValue.isString().stringValue(); |
| if (structureIdOuMessage.matches("^[0-9]+$")) { |
| info.setDonnee(structureIdOuMessage); |
| } else { |
| info.setMessage(structureIdOuMessage); |
| } |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void modifier(String structureId, Structure str, StructureConservation conservation, StructureValorisation valorisation) { |
| String postDonneesEncodees = construirePost(structureId, str, conservation, valorisation); |
| String[] parametres = {structureId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| // Si la requête est un succès, reception d'une chaine |
| if (responseValue.isString() != null) { |
| Information info = new Information("modif_structure"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| public void supprimer(String structuresId) { |
| String[] parametres = {utilisateurId, structuresId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("suppression_structure"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| private String construirePost(String structureId, Structure str, StructureConservation conservation, StructureValorisation valorisation) { |
| String postDonnees = "cmhl_ce_modifier_par=" + URL.encodeComponent(utilisateurId); |
| if (str != null) { |
| if (structureId != null) { |
| postDonnees += "&cs_id_structure=" + URL.encodeComponent(structureId); |
| } |
| postDonnees += "&cpr_abreviation=" + URL.encodeComponent(str.getAbreviationProjet()); |
| postDonnees += "&cs_ce_projet=" + URL.encodeComponent(str.getIdProjet()) + |
| "&cs_ce_mere=" + URL.encodeComponent(str.getIdMere()) + |
| "&cs_guid=" + URL.encodeComponent(str.getGuid()) + |
| "&cs_truk_identifiant_alternatif=" + URL.encodeComponent(str.getIdAlternatif()) + |
| "&cs_nom=" + URL.encodeComponent(str.getNom()) + |
| "&cs_truk_nom_alternatif=" + URL.encodeComponent(str.getNomAlternatif()) + |
| "&cs_description=" + URL.encodeComponent(str.getDescription()) + |
| "&cs_ce_type=" + URL.encodeComponent(str.getType()) + |
| "&cs_ce_truk_type_prive=" + URL.encodeComponent(str.getTypePrive()) + |
| "&cs_ce_truk_type_public=" + URL.encodeComponent(str.getTypePublic()) + |
| "&cs_adresse_01=" + URL.encodeComponent(str.getAdresse()) + |
| "&cs_adresse_02=" + URL.encodeComponent(str.getAdresseComplement()) + |
| "&cs_date_fondation=" + URL.encodeComponent(str.getDateFondationFormatMysql()) + |
| "&cs_code_postal=" + URL.encodeComponent(str.getCodePostal()) + |
| "&cs_ville=" + URL.encodeComponent(str.getVille()) + |
| "&cs_ce_truk_region=" + URL.encodeComponent(str.get("ce_truk_region").toString()) + |
| "&cs_ce_truk_pays=" + URL.encodeComponent(str.getPays()) + |
| "&cs_latitude=" + URL.encodeComponent(str.getLatitude()) + |
| "&cs_longitude=" + URL.encodeComponent(str.getLongitude()) + |
| "&cs_truk_telephone=" + URL.encodeComponent(str.getTelephone()) + |
| "&cs_truk_url=" + URL.encodeComponent(str.getUrl()) + |
| "&cs_nbre_personne=" + URL.encodeComponent(Integer.toString(str.getNbrePersonne())) + |
| "&cs_condition_acces=" + URL.encodeComponent(str.getConditionAcces())+ |
| "&cs_condition_usage=" + URL.encodeComponent(str.getConditionUsage())+ |
| "&cs_courriel=" + URL.encodeComponent(str.getCourriel()); |
| } |
| if (conservation != null) { |
| if (structureId != null) { |
| postDonnees += "&csc_id_structure=" + URL.encodeComponent(structureId); |
| } |
| postDonnees += "&csc_mark_formation=" + URL.encodeComponent(conservation.getFormation()) + |
| "&csc_formation=" + URL.encodeComponent(conservation.getFormationInfo()) + |
| "&csc_mark_formation_interet=" + URL.encodeComponent(conservation.getFormationInteret()) + |
| "&csc_truk_stockage_local=" + URL.encodeComponent(conservation.getStockageLocal()) + |
| "&csc_truk_stockage_meuble=" + URL.encodeComponent(conservation.getStockageMeuble()) + |
| "&csc_truk_stockage_parametre=" + URL.encodeComponent(conservation.getStockageParametre()) + |
| "&csc_mark_collection_commune=" + URL.encodeComponent(conservation.getCollectionCommune()) + |
| "&csc_truk_collection_autre=" + URL.encodeComponent(conservation.getCollectionAutre()) + |
| "&csc_mark_acces_controle=" + URL.encodeComponent(conservation.getAccesControle()) + |
| "&csc_mark_restauration=" + URL.encodeComponent(conservation.getRestauration()) + |
| "&csc_truk_restauration_operation=" + URL.encodeComponent(conservation.getRestaurationOperation()) + |
| "&csc_ce_materiel_conservation=" + URL.encodeComponent(conservation.getMaterielConservation()) + |
| "&csc_truk_materiel_autre=" + URL.encodeComponent(conservation.getMaterielAutre()) + |
| "&csc_mark_traitement=" + URL.encodeComponent(conservation.getTraitement()) + |
| "&csc_truk_traitement=" + URL.encodeComponent(conservation.getTraitements()) + |
| "&csc_mark_acquisition_collection=" + URL.encodeComponent(conservation.getAcquisitionCollection()) + |
| "&csc_mark_acquisition_echantillon=" + URL.encodeComponent(conservation.getAcquisitionEchantillon()) + |
| "&csc_mark_acquisition_traitement=" + URL.encodeComponent(conservation.getAcquisitionTraitement()) + |
| "&csc_truk_acquisition_traitement_poison=" + URL.encodeComponent(conservation.getAcquisitionTraitementPoison()) + |
| "&csc_truk_acquisition_traitement_insecte=" + URL.encodeComponent(conservation.getAcquisitionTraitementInsecte()); |
| } |
| if (valorisation != null) { |
| if (structureId != null) { |
| postDonnees += "&csv_id_structure=" + URL.encodeComponent(structureId); |
| } |
| postDonnees += "&csv_mark_action=" + URL.encodeComponent(valorisation.getAction()) + |
| "&csv_truk_action=" + URL.encodeComponent(valorisation.getActionInfo()) + |
| "&csv_publication=" + URL.encodeComponent(valorisation.getPublication()) + |
| "&csv_collection_autre=" + URL.encodeComponent(valorisation.getCollectionAutre()) + |
| "&csv_mark_action_future=" + URL.encodeComponent(valorisation.getActionFuture()) + |
| "&csv_action_future=" + URL.encodeComponent(valorisation.getActionFutureInfo()) + |
| "&csv_mark_recherche=" + URL.encodeComponent(valorisation.getRecherche()) + |
| "&csv_truk_recherche_provenance=" + URL.encodeComponent(valorisation.getRechercheProvenance()) + |
| "&csv_truk_recherche_type=" + URL.encodeComponent(valorisation.getRechercheType()) + |
| "&csv_mark_acces_ss_motif=" + URL.encodeComponent(valorisation.getAccesSansMotif()) + |
| "&csv_acces_ss_motif=" + URL.encodeComponent(valorisation.getAccesSansMotifInfo()) + |
| "&csv_mark_visite_avec_motif=" + URL.encodeComponent(valorisation.getVisiteAvecMotif()) + |
| "&csv_visite_avec_motif=" + URL.encodeComponent(valorisation.getVisiteAvecMotifInfo()); |
| } |
| return postDonnees; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/structure/StructureAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/ValeurListeAsyncDao.java |
|---|
| New file |
| 0,0 → 1,296 |
| package org.tela_botanica.client.modeles; |
| import java.util.HashMap; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| import org.tela_botanica.client.http.JsonRestRequestCallback; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.synchronisation.Reponse; |
| import org.tela_botanica.client.synchronisation.Sequenceur; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONBoolean; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| public class ValeurListeAsyncDao { |
| private static HashMap<String, Object> ontologieCache = new HashMap<String, Object>(); |
| private static final String SERVICE_NOM = "CoelValeurListe"; |
| private Rafraichissable vueARafraichir = null; |
| private int cptPage = 0; |
| // FIXME : limiteJREST devrait être récupéré depuis un registre/dictionnaire |
| private int limiteJREST = 150; |
| public ValeurListeAsyncDao(Rafraichissable vueCourante) { |
| vueARafraichir = vueCourante; |
| if (Mediateur.DEBUG) System.out.println("|| ValeurListeAsyncDao > vueARafraichir = "+vueARafraichir.getClass().toString()); |
| } |
| public static HashMap<String, Object> getOntologieCache() { |
| return ontologieCache; |
| } |
| public void obtenirListe(Integer cle, Integer seqId) { |
| selectionner("id", cle, null, null, false, null, -1, -1, seqId); |
| } |
| public void obtenirListe(String type, String identifiantValeur, Integer seqId) { |
| selectionner(type, null, null, identifiantValeur, false, null, -1, -1, seqId); |
| } |
| public void obtenirListe(Integer cle, boolean pagination, String recherche, int start, int limit, Integer seqId) { |
| selectionner("nom", cle, null, null, pagination, recherche, start, limit, seqId); |
| } |
| public void selectionner(String type, Integer cle, String abv, String idValeur, Integer seqId) { |
| 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 .... |
| **/ |
| final String cleParentPourCache = cle + (abv == null ? "" : abv); |
| final String cleParent = cle+""; |
| /** GESTION DU PARAMETRE 'recherche' **/ |
| String nom = ""; |
| if ( (recherche == null) || (recherche.equals("")) ) nom = ""; |
| else { |
| 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)+"%"; |
| else abreviation=abv+"%"; |
| } |
| 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)); |
| 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() |
| { |
| /** RECEPTION DE LA REPONSE **/ |
| public void surReponse(JSONValue responseValue) |
| { |
| if (vueARafraichir instanceof Sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste paginée, retour au 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 { |
| if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste paginée, retour à "+vueARafraichir.getClass().toString()); |
| 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); |
| /** 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 { |
| restrictions.put("orderby", "cmlv_nom"); |
| } |
| /** 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 **/ |
| if (vueARafraichir instanceof Sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour au sequenceur"); |
| vueARafraichir = (Sequenceur) vueARafraichir; |
| Reponse reponse = new Reponse(ontologieCache.get(cleParentPourCache), seqId); |
| vueARafraichir.rafraichir(reponse); |
| } else { |
| if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour à "+vueARafraichir.getClass().toString()); |
| 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); |
| /** 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(); |
| JSONNumber nbElements = reponse.get("nbElements").isNumber(); |
| JSONBoolean getNextPage = reponse.get("getNextPage").isBoolean(); |
| /** Gestion de l'abreviation (pour la liste des régions) **/ |
| String abreviationStr = ""; |
| if (reponse.get("abreviation") != null) { |
| abreviationStr = reponse.get("abreviation").isString().stringValue(); |
| int a = abreviationStr.indexOf("%", 1); |
| abreviationStr = abreviationStr.substring(1, a); |
| } |
| else { |
| abreviationStr = ""; |
| } |
| /** Si l'on a bien reçu une liste de valeurs **/ |
| if (listeId != null) |
| { |
| /** Transformation du tableau JSON réponse en ValeurListe **/ |
| String id = listeId.stringValue(); |
| ValeurListe liste = new ValeurListe(new JSONString(id), abreviationStr, listeValeurs, nbElements); |
| /** Si la liste existe deja en cache **/ |
| String identifiantCache = (abreviationStr=="") ? id : (id+abreviationStr); |
| if (ontologieCache.get(id) != null) |
| { |
| /** Alors on concatène la liste existante avec celle qu'on vient de recevoir **/ |
| ((ValeurListe)ontologieCache.get(identifiantCache)).concatenerListe(liste); |
| } |
| /** Sinon on l'insère simplement dans le cache **/ |
| else { |
| ontologieCache.put(identifiantCache,liste); |
| } |
| /** Appel à la méthode qui gère le retour à l'appelant ou la suite du chargement **/ |
| chargerListe(getNextPage.booleanValue(), type, liste.getId(), abv, idValeur, pagination, recherche, start, limit, seqId); |
| } |
| } |
| } |
| }); |
| } |
| } |
| } |
| /******************************************************************************************************** |
| * 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; |
| } |
| /** On retourne la liste à la vue **/ |
| if (ontologieCache.get(id) != null) { |
| if (vueARafraichir instanceof Sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour au sequenceur (cptPage="+cptPage+")"); |
| vueARafraichir = (Sequenceur) vueARafraichir; |
| Reponse reponse = new Reponse(ontologieCache.get(id), seqId); |
| vueARafraichir.rafraichir(reponse); |
| } else { |
| if (Mediateur.DEBUG) System.out.println("<-- ValeurListeAsyncDao > Liste en cache, retour à "+vueARafraichir.getClass().toString()); |
| vueARafraichir.rafraichir(ontologieCache.get(id)); |
| } |
| } |
| // réinitialisation du compteur |
| cptPage = 0; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/ValeurListeAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/InterneValeur.java |
|---|
| New file |
| 0,0 → 1,32 |
| package org.tela_botanica.client.modeles; |
| import com.extjs.gxt.ui.client.data.BaseModelData; |
| public class InterneValeur extends BaseModelData { |
| private static final long serialVersionUID = 8587069259740389877L; |
| public InterneValeur() { |
| } |
| public InterneValeur(String abr, String nom) { |
| setAbr(abr); |
| setNom(nom); |
| } |
| public String getNom() { |
| return get("nom"); |
| } |
| public void setNom(String nom) { |
| set("nom", nom); |
| } |
| public String getAbr() { |
| return get("abr"); |
| } |
| public void setAbr(String abr) { |
| set("abr", abr); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/InterneValeur.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/commentaire/Commentaire.java |
|---|
| New file |
| 0,0 → 1,141 |
| package org.tela_botanica.client.modeles.commentaire; |
| import org.tela_botanica.client.Mediateur; |
| 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; |
| public class Commentaire extends aDonnee { |
| private static final long serialVersionUID = 7216356814682582569L; |
| private static final String PREFIXE = "ccm"; |
| private Collection collection = null; |
| private CollectionACommentaire collectionACommentaire = null; |
| public static String[] champsObligatoires = {"ccm_id_commentaire"}; |
| public Commentaire() { |
| } |
| public Commentaire(JSONObject commentaire) { |
| initialiserCommentaire(commentaire, false); |
| } |
| public Commentaire(JSONObject commentaire, boolean chargerCollectionACommentaire) { |
| initialiserCommentaire(commentaire, chargerCollectionACommentaire); |
| } |
| public void initialiserCommentaire(JSONObject commentaire, boolean chargerCollectionACommentaire) { |
| initialiserModele(commentaire); |
| collection = new Collection(commentaire); |
| if (chargerCollectionACommentaire) { |
| collectionACommentaire = new CollectionACommentaire(commentaire); |
| } else { |
| collectionACommentaire = new CollectionACommentaire(); |
| } |
| initialiserChampsPourGrille(); |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| private void initialiserChampsPourGrille() { |
| set("_collection_nom_", getCollection().getNom()); |
| set("_type_", getCollectionACommentaire().getType()); |
| set("_titre_", getTitre()); |
| set("_texte_", getTexteResume()); |
| set("_ponderation_", getPonderation()); |
| set("_public_", getPublic()); |
| set("_etat_", ""); |
| } |
| public Collection getCollection() { |
| if (collection == null) { |
| collection = new Collection(); |
| } |
| return collection; |
| } |
| public void setCollection(Collection collectionAStocker) { |
| collection = collectionAStocker; |
| } |
| public CollectionACommentaire getCollectionACommentaire() { |
| if (collectionACommentaire == null) { |
| collectionACommentaire = new CollectionACommentaire(); |
| } |
| return collectionACommentaire; |
| } |
| public void setCollectionACommentaire(CollectionACommentaire collectionACommentaireAStocker) { |
| collectionACommentaire = collectionACommentaireAStocker; |
| } |
| public String getId() { |
| return renvoyerValeurCorrecte("id_commentaire"); |
| } |
| public void setId(String idCommentaire) { |
| this.set("id_commentaire", idCommentaire); |
| } |
| public String getIdProjet() { |
| return renvoyerValeurCorrecte("ce_projet"); |
| } |
| public void setIdProjet(String idProjet) { |
| this.set("ce_projet", idProjet); |
| } |
| public String getCommentairePereId() { |
| return renvoyerValeurCorrecte("ce_pere"); |
| } |
| public void setCommentairePereId(String idPere) { |
| this.set("ce_pere", idPere); |
| } |
| public String getTitre() { |
| return renvoyerValeurCorrecte("titre"); |
| } |
| public void setTitre(String titre) { |
| this.set("titre", titre); |
| } |
| public String getTexteResume() { |
| String resume = getTexte(); |
| if (getTexte().length() > 100) { |
| resume = getTexte().substring(0, 100); |
| } |
| return resume; |
| } |
| public String getTexte() { |
| return renvoyerValeurCorrecte("texte"); |
| } |
| public void setTexte(String texte) { |
| this.set("texte", texte); |
| } |
| public String getPonderation() { |
| return renvoyerValeurCorrecte("ponderation"); |
| } |
| public void setPonderation(String ponderation) { |
| this.set("ponderation", ponderation); |
| } |
| public boolean etrePublic() { |
| return (getPublic().equals("1") ? true : false); |
| } |
| public String getPublic() { |
| return renvoyerValeurCorrecte("mark_public"); |
| } |
| public void setPublic(String publique) { |
| this.set("mark_public", publique); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/commentaire/Commentaire.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/commentaire/CommentaireListe.java |
|---|
| New file |
| 0,0 → 1,135 |
| package org.tela_botanica.client.modeles.commentaire; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| 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; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Classe contenant les informations sur les Commentaires renvoyées par un objet de type DAO. |
| * |
| * @author Jean-Pascal MILCENT |
| * |
| */ |
| public class CommentaireListe extends aDonneeListe<Commentaire> implements ListePaginable { |
| private static final long serialVersionUID = 2600314321196345072L; |
| private int currentPage = 0; |
| private int nbElementsPage = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); |
| private int nbElementsTotal; |
| private Rafraichissable vueARafraichir; |
| public CommentaireListe() { |
| super(); |
| } |
| public CommentaireListe(int taille) { |
| super(taille); |
| } |
| /** |
| * Constructeur pour une liste de commentaires |
| * @param dates |
| */ |
| public CommentaireListe(JSONArray ListeDeCommentaires) { |
| super(ListeDeCommentaires.size()); |
| initialiserCommentaireListe(ListeDeCommentaires); |
| } |
| public CommentaireListe(JSONArray ListeDeCommentaires, JSONNumber nbElements, Rafraichissable vueARafraichir) { |
| super(ListeDeCommentaires.size()); |
| this.nbElementsTotal = Integer.valueOf(nbElements.toString()); |
| this.vueARafraichir = vueARafraichir; |
| initialiserCommentaireListe(ListeDeCommentaires); |
| } |
| 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); |
| if (!UtilString.isEmpty(commentaire.getCollectionACommentaire().getId())) { |
| this.put(commentaire.getCollectionACommentaire().getId(), commentaire); |
| } |
| else { |
| this.put(commentaire.getId(), commentaire); |
| } |
| } |
| } |
| } |
| public void changerNumeroPage(int pageCourante) { |
| currentPage = pageCourante; |
| selectionnerCommentaire(); |
| } |
| public void changerTaillePage(int nouvelleTaillePage) { |
| nbElementsPage = nouvelleTaillePage; |
| selectionnerCommentaire(); |
| } |
| public void recharger() { |
| selectionnerCommentaire(); |
| } |
| public void setPageCourante(int pageCourante) { |
| this.currentPage = pageCourante; |
| } |
| public void setTaillePage(int taillePage) { |
| this.nbElementsPage = taillePage; |
| } |
| public int[] getPageTable() { |
| int[] page = new int[4]; |
| // nombre de pages au total |
| page[0] = calculerNbPages(); |
| // Page En Cours |
| page[1] = currentPage; |
| // nbElementsParPage |
| page[2] = nbElementsPage; |
| // et le dernier le nombre total d'éléments |
| page[3] = nbElementsTotal; |
| return page; |
| } |
| /** |
| * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements |
| * donnés en fonction de la taille de page en cours |
| * |
| * @return le nombre de pages |
| */ |
| public int calculerNbPages() { |
| // À cause de la bétise de java pour les conversion implicite, on fait quelques conversions manuellement |
| // pour eviter qu'il arrondisse mal la division nombre de pages = (nombre d'element / taille de la page) |
| // arrondie à l'entier supérieur. |
| double nPage = (1.0 * nbElementsTotal) / (1.0 * nbElementsPage); |
| double nPageRound = Math.ceil(nPage); |
| Double nPageInt = new Double(nPageRound); |
| // Convertion en entier |
| return nPageInt.intValue(); |
| } |
| public void selectionnerCommentaire() { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerCommentaire(vueARafraichir, null, null, currentPage, nbElementsPage, null); |
| } |
| public void filtrerParNom(String nom) { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerCommentaireParTitre(vueARafraichir, "%" + nom + "%", null); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/commentaire/CommentaireListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/commentaire/CommentaireAsyncDao.java |
|---|
| New file |
| 0,0 → 1,154 |
| package org.tela_botanica.client.modeles.commentaire; |
| import java.util.HashMap; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.util.UtilDAO; |
| 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 CommentaireAsyncDao { |
| private static final String SERVICE_NOM = "CoelCommentaire"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public CommentaireAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| CommentaireAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante ; |
| utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId(); |
| } |
| public void selectionner(final String commentaireId, String projetId, String titre, final int pageCourante, final int nbElements, final Integer seqId) { |
| String[] parametres = {projetId, commentaireId, titre}; |
| HashMap<String, String> restrictions = new HashMap<String, String>(); |
| restrictions.put("start", String.valueOf(pageCourante*nbElements)); |
| if (nbElements != -1) { |
| restrictions.put("limit", String.valueOf(nbElements)); |
| } |
| restrictions.put("orderby", "cc_nom ASC"); |
| 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, 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 |
| Commentaire commentaire = new Commentaire(reponse); |
| // et on met à jour le demandeur des données |
| if (seqId != null) { |
| Reponse reponseRequete = new Reponse(commentaire, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| vueARafraichir.rafraichir(commentaire); |
| } |
| } else if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| CommentaireListe commentaires; |
| if (reponse.get(1).isObject() != null) { |
| commentaires = new CommentaireListe(reponse.get(1).isArray()); |
| } else { |
| commentaires = new CommentaireListe(reponse.get(1).isArray(), reponse.get(0).isNumber(), vueARafraichir); |
| } |
| commentaires.setTaillePage(nbElements); |
| commentaires.setPageCourante(pageCourante); |
| if (seqId != null) { |
| Reponse reponseRequete = new Reponse(commentaires, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| vueARafraichir.rafraichir(commentaires); |
| } |
| } else { |
| GWT.log("La réponse n'est pas un objet ou un talbeau JSON et vaut : "+responseValue.toString(), null); |
| } |
| } else { |
| // Dans le cas, où nous demandons toutes les publication et qu'il n'y en a pas, nous retournons un objet vide |
| if (commentaireId == null) { |
| CommentaireListe commentaires = new CommentaireListe(0); |
| if (seqId != null) { |
| Reponse reponseRequete = new Reponse(commentaires, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| vueARafraichir.rafraichir(commentaires); |
| } |
| } |
| } |
| } |
| }); |
| } |
| public void ajouter(Commentaire commentaire) { |
| String postDonneesEncodees = commentaire.obtenirChainePOST()+"&cmhl_ce_modifier_par="+utilisateurId; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "ajout_commentaire"); |
| } |
| }) ; |
| } |
| public void modifier(Commentaire commentaire) { |
| String[] parametres = {commentaire.getId()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| String postDonneesEncodees = commentaire.obtenirChainePOST()+"&cmhl_ce_modifier_par="+utilisateurId; |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "modif_commentaire"); |
| } |
| }); |
| } |
| public void supprimer(String commentairesId) { |
| String[] parametres = {utilisateurId, commentairesId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "suppression_commentaire"); |
| } |
| }); |
| } |
| private void traiterReponse(JSONValue reponseValeur, String type) { |
| Information info = new Information(type); |
| // Si la requête est un succès, réception d'une chaîne |
| if (reponseValeur.isString() != null) { |
| String idOuMessage = reponseValeur.isString().stringValue(); |
| if (idOuMessage.matches("^[0-9]+$")) { |
| info.setDonnee(idOuMessage); |
| } else { |
| info.setMessage(idOuMessage); |
| } |
| } else { |
| info.setDeboguage("La réponse n'est pas une chaine JSON."); |
| } |
| vueARafraichir.rafraichir(info); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/commentaire/CommentaireAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/projet/ProjetVersion.java |
|---|
| New file |
| 0,0 → 1,84 |
| package org.tela_botanica.client.modeles.projet; |
| import java.util.Iterator; |
| import java.util.Set; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import com.google.gwt.json.client.JSONObject; |
| public class ProjetVersion extends aDonnee { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 1L; |
| private static final String PREFIXE = "cprv"; |
| public static String[] champsObligatoires = {"cpr_id_projet"}; |
| public ProjetVersion() { |
| //this.set("mark_contact", false); |
| super(); |
| } |
| public ProjetVersion(JSONObject liste) { |
| // l'objet JSON est une table de hachage |
| Set<String> im = liste.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| if (liste.get(cle).isString() != null) { |
| String valeur = liste.get(cle).isString().stringValue(); |
| this.set(cleObjet, valeur); |
| } else { |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = " "; |
| this.set(cleObjet, valeur); |
| } |
| } |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| public String getIdVersion() { |
| return renvoyerValeurCorrecte("id_version"); |
| } |
| public String getIdProjet() { |
| return renvoyerValeurCorrecte("id_projet"); |
| } |
| public String getNom() { |
| return renvoyerValeurCorrecte("nom"); |
| } |
| public String getCode() { |
| return renvoyerValeurCorrecte("code"); |
| } |
| public String getDateDebut() { |
| return renvoyerValeurCorrecte("date_debut"); |
| } |
| public String getDateFin() { |
| return renvoyerValeurCorrecte("date_fin"); |
| } |
| public String getMeta() { |
| return renvoyerValeurCorrecte("ce_meta "); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/projet/ProjetVersion.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/projet/Projet.java |
|---|
| New file |
| 0,0 → 1,147 |
| package org.tela_botanica.client.modeles.projet; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| 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 { |
| private static final long serialVersionUID = 6733053168274995082L; |
| private static final String PREFIXE = "cpr"; |
| public static String[] champsObligatoires = {"cpr_id_projet"}; |
| public Projet() {} |
| public Projet(JSONObject liste) { |
| initialiserModele(liste); |
| } |
| public Projet(ModelData model) |
| { |
| Map<String, Object> a = model.getProperties(); |
| Set<String> cles = a.keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| if (a.get(cle) != null) { |
| String cleObjet = cle.replaceFirst("^"+getPrefixe()+"_", ""); |
| this.set(cleObjet, a.get(cle)); |
| } |
| } |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| public String getId() { |
| return renvoyerValeurCorrecte("id_projet"); |
| } |
| public void setId(String projetId) { |
| set("id_projet", projetId); |
| } |
| public String getNom() { |
| return renvoyerValeurCorrecte("nom"); |
| } |
| public void setNom(String nom) { |
| set("nom", nom); |
| } |
| public String getAbreviation() { |
| return renvoyerValeurCorrecte("abreviation"); |
| } |
| public void setAbreviation(String abrev) { |
| set("abreviation", abrev); |
| } |
| public String getResume() { |
| return renvoyerValeurCorrecte("resume"); |
| } |
| public void setResume(String valeur) { |
| set("resume", valeur); |
| } |
| public String getDescription() { |
| return renvoyerValeurCorrecte("description"); |
| } |
| public void setDescription(String valeur) { |
| set("description", valeur); |
| } |
| public String getUrl() { |
| return renvoyerValeurCorrecte("url"); |
| } |
| public void setUrl(String valeur) { |
| set("url", valeur); |
| } |
| public String getMotsCles() { |
| return renvoyerValeurCorrecte("mot_cles"); |
| } |
| public void setMotsCles(String valeur) { |
| set("mot_cles", valeur); |
| } |
| public String getCitation() { |
| return renvoyerValeurCorrecte("citation"); |
| } |
| public void setCitation(String valeur) { |
| set("citation", valeur); |
| } |
| public String getLicence() { |
| return renvoyerValeurCorrecte("licence"); |
| } |
| public void setLicence(String valeur) { |
| set("licence", valeur); |
| } |
| public String getLangue() { |
| return renvoyerValeurCorrecte("ce_langue"); |
| } |
| public void setLangue(String valeur) { |
| set("ce_langue", valeur); |
| } |
| public String getIndexationHeure() { |
| return renvoyerValeurCorrecte("indexation_heure"); |
| } |
| public void setIndexationHeure(String valeur) { |
| set("indexation_heure", valeur); |
| } |
| public String getIndexationDuree() { |
| return renvoyerValeurCorrecte("ce_indexation_duree"); |
| } |
| public void setIndexationDuree(String valeur) { |
| set("ce_indexation_duree", valeur); |
| } |
| public String getIndexationFreq() { |
| return renvoyerValeurCorrecte("ce_indexation_freq"); |
| } |
| public void setIndexationFreq(String valeur) { |
| set("ce_indexation_freq", valeur); |
| } |
| public String getMarkPublic() { |
| return renvoyerValeurCorrecte("mark_public"); |
| } |
| public void setMarkPublic(String valeur) { |
| set("mark_public", valeur); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/projet/Projet.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/projet/ProjetListe.java |
|---|
| New file |
| 0,0 → 1,130 |
| package org.tela_botanica.client.modeles.projet; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.i18n.client.Dictionary; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Classe contenant les informations sur les Structures renvoyées par un objet de type DAO. |
| * |
| * @author Grégoire DUCHÉ |
| * |
| */ |
| public class ProjetListe extends aDonneeListe<Projet> implements ListePaginable { |
| private static final long serialVersionUID = -9030260944108896455L; |
| private int currentPage = 0; |
| private int nbElementsPage = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); |
| private int nbElementsTotal; |
| private Rafraichissable vueARafraichir; |
| public ProjetListe() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ProjetListe(int taille) { |
| super(taille); |
| } |
| /** |
| * Constructeur pour une liste de projets |
| * @param dates |
| */ |
| public ProjetListe(JSONArray ListeDeProjets) { |
| super(ListeDeProjets.size()); |
| initialiserProjetListe(ListeDeProjets); |
| } |
| public ProjetListe(JSONArray ListeDeProjets, JSONNumber nbElements, Rafraichissable vueARafraichir) { |
| super(ListeDeProjets.size()); |
| this.nbElementsTotal = Integer.valueOf(nbElements.toString()); |
| this.vueARafraichir = vueARafraichir; |
| initialiserProjetListe(ListeDeProjets); |
| } |
| private void initialiserProjetListe(JSONArray ListeDeProjets) { |
| final int taillemax = ListeDeProjets.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject projetCourant = ListeDeProjets.get(i).isObject(); |
| if (projetCourant != null) { |
| Projet projet = new Projet(projetCourant); |
| this.put(projet.getId(), projet); |
| } |
| } |
| } |
| public void changerNumeroPage(int pageCourante) { |
| currentPage = pageCourante; |
| selectionnerStructure(); |
| } |
| public void changerTaillePage(int nouvelleTaillePage) { |
| nbElementsPage = nouvelleTaillePage; |
| selectionnerStructure(); |
| } |
| public void recharger() { |
| selectionnerStructure(); |
| } |
| public void setPageCourante(int pageCourante) { |
| this.currentPage = pageCourante; |
| } |
| public void setTaillePage(int taillePage) { |
| this.nbElementsPage = taillePage; |
| } |
| public int[] getPageTable() { |
| int[] page = new int[4]; |
| // nombre de pages au total |
| page[0] = calculerNbPages(); |
| // Page En Cours |
| page[1] = currentPage; |
| // nbElementsParPage |
| page[2] = nbElementsPage; |
| // et le dernier le nombre total d'éléments |
| page[3] = nbElementsTotal; |
| return page; |
| } |
| /** |
| * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements |
| * donnés en fonction de la taille de page en cours |
| * |
| * @return le nombre de pages |
| */ |
| public int calculerNbPages() { |
| // À cause de la bétise de java pour les conversion implicite, on fait quelques conversions manuellement |
| // pour eviter qu'il arrondisse mal la division nombre de pages = (nombre d'element / taille de la page) |
| // arrondie à l'entier supérieur. |
| double nPage = (1.0 * nbElementsTotal) / (1.0 * nbElementsPage); |
| double nPageRound = Math.ceil(nPage); |
| Double nPageInt = new Double(nPageRound); |
| // Convertion en entier |
| return nPageInt.intValue(); |
| } |
| public void selectionnerStructure() { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerProjet(vueARafraichir, mediateur.getProjetId(), null, currentPage, nbElementsPage, null); |
| } |
| public void filtrerParNom(String nom) { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerProjet(vueARafraichir, mediateur.getProjetId(), "%" + nom + "%", 0, nbElementsPage, null); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/projet/ProjetListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/projet/ProjetAsyncDao.java |
|---|
| New file |
| 0,0 → 1,212 |
| package org.tela_botanica.client.modeles.projet; |
| import java.util.HashMap; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.extjs.gxt.ui.client.widget.Info; |
| 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 ProjetAsyncDao { |
| private static final String SERVICE_NOM = "CoelProjet"; |
| String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public ProjetAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| ProjetAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante; |
| 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, 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>(); |
| if (nbElements != -1) { |
| restrictions.put("limit", String.valueOf(nbElements)); |
| } |
| /** 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 **/ |
| if (seqId != null) { |
| Reponse reponseRequete = new Reponse(responseValue, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| 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, param, restrictions); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| 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 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); |
| 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 tableau JSON et vaut : "+responseValue.toString(), null); |
| } |
| } 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); |
| if (seqId != null) { |
| Reponse reponseRequete = new Reponse(projets, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } |
| else { |
| vueARafraichir.rafraichir(projets); |
| } |
| } |
| } |
| } |
| }); |
| } |
| } |
| public void ajouter(Projet projet) { |
| String postDonneesEncodees = projet.obtenirChainePOST()+"&cmhl_ce_modifier_par="+utilisateurId; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "ajout_projet"); |
| } |
| }) ; |
| } |
| public void modifier(Projet projet) { |
| String[] parametres = {projet.getId()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| String postDonneesEncodees = projet.obtenirChainePOST()+"&cmhl_ce_modifier_par="+utilisateurId; |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "modif_projet"); |
| } |
| }); |
| } |
| public void supprimer(String projetsId) { |
| String[] parametres = {utilisateurId, projetsId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "suppression_projet"); |
| } |
| }); |
| } |
| private void traiterReponse(JSONValue reponseValeur, String type) { |
| Information info = new Information(type); |
| String idsNonSuppr = ""; |
| // Si la requête est un succès, réception d'une chaîne |
| if (type.equals("suppression_projet") && reponseValeur.isArray() != null) { |
| JSONArray tableauInfo = reponseValeur.isArray(); |
| idsNonSuppr = tableauInfo.get(0).isString().stringValue(); |
| } else if (reponseValeur.isString() != null) { |
| String idOuMessage = reponseValeur.isString().stringValue(); |
| if (idOuMessage.matches("^[0-9]+$")) { |
| info.setDonnee(idOuMessage); |
| } else { |
| info.setDonnee(""); |
| info.setMessage(idOuMessage); |
| } |
| } else { |
| info.setDeboguage("La réponse n'est pas une chaine JSON."); |
| } |
| info.setDonnee(1, idsNonSuppr); |
| vueARafraichir.rafraichir(info); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/projet/ProjetAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/InterneValeurListe.java |
|---|
| New file |
| 0,0 → 1,39 |
| package org.tela_botanica.client.modeles; |
| import java.util.ArrayList; |
| import java.util.List; |
| public class InterneValeurListe { |
| public static List<InterneValeur> getTypeAcronyme() { |
| List<InterneValeur> acronymes = new ArrayList<InterneValeur>(); |
| acronymes.add(new InterneValeur("", "Aucun")); |
| acronymes.add(getTypeAcronymeIH()); |
| acronymes.add(getTypeAcronymeMNHN()); |
| return acronymes; |
| } |
| public static List<InterneValeur> getTypeStructure() { |
| List<InterneValeur> types = new ArrayList<InterneValeur>(); |
| types.add(new InterneValeur("", "Aucun")); |
| types.add(getTypePublique()); |
| types.add(getTypePrivee()); |
| return types; |
| } |
| public static InterneValeur getTypePublique() { |
| return new InterneValeur("stpu", "Publique"); |
| } |
| public static InterneValeur getTypePrivee() { |
| return new InterneValeur("stpr", "Privée"); |
| } |
| public static InterneValeur getTypeAcronymeIH() { |
| return new InterneValeur("IH", "Index Herbariorum"); |
| } |
| public static InterneValeur getTypeAcronymeMNHN() { |
| return new InterneValeur("MNHN", "Muséum National d'Histoire Naturelle de Paris"); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/InterneValeurListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/Information.java |
|---|
| New file |
| 0,0 → 1,119 |
| package org.tela_botanica.client.modeles; |
| import java.util.ArrayList; |
| import com.google.gwt.json.client.JSONArray; |
| public class Information { |
| private String type = null; |
| private ArrayList<String> messages = null; |
| private ArrayList<String> deboguages = null; |
| private ArrayList<Object> donnees = null; |
| public Information() { |
| donnees = new ArrayList<Object>(); |
| messages = new ArrayList<String>(); |
| deboguages = new ArrayList<String>(); |
| } |
| public Information(String t) { |
| donnees = new ArrayList<Object>(); |
| messages = new ArrayList<String>(); |
| deboguages = new ArrayList<String>(); |
| type = t; |
| } |
| public Information(String t, String m) { |
| donnees = new ArrayList<Object>(); |
| messages = new ArrayList<String>(); |
| messages.add(m); |
| deboguages = new ArrayList<String>(); |
| type = t; |
| } |
| public Information(String t, JSONArray jsonArray) { |
| donnees = new ArrayList<Object>(); |
| messages = new ArrayList<String>(); |
| for(int i = 0 ; i < jsonArray.size() ; i++) { |
| if (jsonArray.get(i).isString() != null) { |
| messages.add(jsonArray.get(i).isString().stringValue()); |
| } |
| } |
| deboguages = new ArrayList<String>(); |
| type = t; |
| } |
| public Information(String t, Object o) { |
| donnees = new ArrayList<Object>(); |
| donnees.add(o); |
| messages = new ArrayList<String>(); |
| deboguages = new ArrayList<String>(); |
| type = t; |
| } |
| public void setType(String t) { |
| type = t; |
| } |
| public String getType() { |
| return type; |
| } |
| public void setMessage(String message) { |
| messages.add(message); |
| } |
| public String getMessage(int index) { |
| return messages.get(index); |
| } |
| public ArrayList<String> getMessages() { |
| return messages; |
| } |
| public void setDeboguage(String messageDeboguage) { |
| deboguages.add(messageDeboguage); |
| } |
| public void setDeboguages(JSONArray jsonArray) { |
| for(int i = 0 ; i < jsonArray.size() ; i++) { |
| if (jsonArray.get(i).isString() != null) { |
| deboguages.add(jsonArray.get(i).isString().stringValue()); |
| } |
| } |
| } |
| public String getDeboguage(int index) { |
| return deboguages.get(index); |
| } |
| public ArrayList<String> getDeboguages() { |
| return deboguages; |
| } |
| public void setDonnee(Object objet) { |
| donnees.add(objet); |
| } |
| public void setDonnee(int index, Object objet) { |
| if (objet != null) { |
| donnees.add(index, objet); |
| } |
| } |
| public Object getDonnee(int index) { |
| try { |
| return donnees.get(index); |
| } catch (Exception e) { |
| return null; |
| } |
| } |
| public ArrayList<Object> getDonnees() { |
| return donnees; |
| } |
| public String toString() { |
| String chaine = new String(); |
| if (messages != null) { |
| for (int i = 0 ; i < messages.size() ; i++) { |
| // GXT ne prend pas en compte /n ou /r/n... |
| chaine += getMessage(i)+"\n"; |
| } |
| } |
| return chaine; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/Information.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/publication/PublicationAPersonne.java |
|---|
| New file |
| 0,0 → 1,155 |
| package org.tela_botanica.client.modeles.publication; |
| import java.util.Iterator; |
| import java.util.Set; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import org.tela_botanica.client.modeles.personne.Personne; |
| import com.google.gwt.json.client.JSONObject; |
| public class PublicationAPersonne extends aDonnee { |
| private static final long serialVersionUID = 7769105365939978129L; |
| public static final String PREFIXE = "cpuap"; |
| public static final String ROLE_AUTEUR = "2360"; |
| //FIXME: insérer en base de données une valeur cohérente pour l'identifiant ci-dessous |
| public static final String ROLE_SUJET = "30762"; |
| private Personne personneLiee = null; |
| private Publication publicationLiee = null; |
| public static String[] champsObligatoires = {"cpuap_id_personne", "cpuap_id_publication", "cpuap_id_role"}; |
| public PublicationAPersonne() { |
| new PublicationAPersonne(new JSONObject()); |
| } |
| public PublicationAPersonne(JSONObject pubAPersListe) { |
| personneLiee = new Personne(pubAPersListe); |
| publicationLiee = new Publication(pubAPersListe); |
| // l'objet JSON est une table de hachage |
| Set<String> im = pubAPersListe.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| // Valeur vide par défaut |
| String valeur = ""; |
| if (pubAPersListe.get(cle).isString() != null) { |
| valeur = pubAPersListe.get(cle).isString().stringValue(); |
| this.set(cleObjet, valeur); |
| } else { |
| this.set(cleObjet, valeur); |
| } |
| } |
| initialiserChampsPourGrille(); |
| } |
| private void initialiserChampsPourGrille() { |
| set("fmt_auteur", publicationLiee.getAuteur()); |
| set("titre", publicationLiee.getTitre()); |
| set("collection", publicationLiee.getCollection()); |
| set("_editeur_", ""); |
| set("_annee_", ""); |
| set("indication_nvt", publicationLiee.getIndicationNvt()); |
| set("fascicule", publicationLiee.getFascicule()); |
| set("truk_pages", publicationLiee.getPages()); |
| set("_etat_", ""); |
| set("_role_", this.get("id_role")); |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| public Personne getPersonne() { |
| return personneLiee; |
| } |
| public void setPersonne(Personne personne) { |
| personneLiee = personne; |
| if (personne != null) { |
| setIdPersonne(personne.getId()); |
| } |
| } |
| // ID |
| public String getId() { |
| String idPublication = getIdPublication(); |
| String idPersonne = getIdPersonne(); |
| String idRole = getIdRole(); |
| if (idPublication.equals("") && idPersonne.equals("") && idRole.equals("")) { |
| return null; |
| } else { |
| return (idPublication+"-"+idPersonne+"-"+idRole); |
| } |
| } |
| // ID PUBLICATION |
| public String getIdPublication() { |
| return renvoyerValeurCorrecte("id_publication"); |
| } |
| public void setIdPublication(String id) { |
| set("id_publication", id); |
| } |
| // PUBLICATION LIEE |
| public Publication getPublicationLiee() { |
| return this.publicationLiee; |
| } |
| // LIER PUBLICATION |
| public void setPublicationLiee(Publication publication) { |
| this.publicationLiee = publication; |
| initialiserChampsPourGrille(); |
| } |
| // ROLE |
| public String getRole() { |
| String role = this.get("_role_"); |
| if (role != null) { |
| return role; |
| } else { |
| return ""; |
| } |
| } |
| // ID PERSONNE |
| public String getIdPersonne() { |
| return renvoyerValeurCorrecte("id_personne"); |
| } |
| public void setIdPersonne(String id) { |
| set("id_personne", id); |
| } |
| // ID RôLE |
| public String getIdRole() { |
| return renvoyerValeurCorrecte("id_role"); |
| } |
| public void setIdRole(String id) { |
| set("id_role", id); |
| } |
| // TYPE |
| public String getType() { |
| return renvoyerValeurCorrecte("ce_truk_type"); |
| } |
| public void setType(String type) { |
| set("ce_truk_type", type); |
| } |
| public void setFonction(String type, String valeur) { |
| setChaineDenormaliseUnique("ce_truk_type", type, valeur); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/publication/PublicationAPersonne.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/publication/PublicationAPersonneListe.java |
|---|
| New file |
| 0,0 → 1,33 |
| package org.tela_botanica.client.modeles.publication; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import org.tela_botanica.client.util.Debug; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| public class PublicationAPersonneListe extends aDonneeListe<PublicationAPersonne> { |
| private static final long serialVersionUID = -5950583940829919577L; |
| public PublicationAPersonneListe() { |
| super(); |
| } |
| public PublicationAPersonneListe(int i) { |
| super(i); |
| } |
| public PublicationAPersonneListe(JSONArray auteurs) { |
| super(auteurs.size()) ; |
| final int taillemax = auteurs.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject publicationAPersonneCourante = auteurs.get(i).isObject() ; |
| if (publicationAPersonneCourante != null) { |
| PublicationAPersonne publicationAPersonne = new PublicationAPersonne(publicationAPersonneCourante); |
| this.put(publicationAPersonne.getId(), publicationAPersonne); |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/publication/PublicationAPersonneListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/publication/PublicationAPersonneAsyncDao.java |
|---|
| New file |
| 0,0 → 1,146 |
| package org.tela_botanica.client.modeles.publication; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.extjs.gxt.ui.client.widget.Window; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONValue; |
| public class PublicationAPersonneAsyncDao { |
| private static final String SERVICE_NOM = "CoelPublicationAPersonne"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public PublicationAPersonneAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| PublicationAPersonneAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante; |
| utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId(); |
| } |
| public void selectionner(String publicationId, String personnesId, String roleId, final Integer seqId) { |
| String[] parametres = {publicationId, personnesId, roleId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue != null) { |
| // Si la requête est un succès, réception d'un objet ou d'un tableau |
| if (responseValue.isObject() != null) { |
| final JSONObject reponse = responseValue.isObject(); |
| // Transformation du tableau JSON réponse en ListeInstitution |
| PublicationAPersonne publicationAPersonne = new PublicationAPersonne(reponse); |
| // et on met à jour le demandeur des données |
| if (seqId!=null) { |
| Reponse reponseRequete = new Reponse(publicationAPersonne, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } else { |
| vueARafraichir.rafraichir(publicationAPersonne); |
| } |
| } else if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| PublicationAPersonneListe publicationsAPersonneListe = new PublicationAPersonneListe(reponse); |
| if (seqId!=null) { |
| Reponse reponseRequete = new Reponse(publicationsAPersonneListe, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } else { |
| vueARafraichir.rafraichir(publicationsAPersonneListe); |
| } |
| } else { |
| GWT.log("La réponse n'est pas un objet ou un tableau JSON et vaut : "+responseValue.toString(), null); |
| } |
| } else { |
| // Dans le cas, où nous demandons toutes les publication et qu'il n'y en a pas, nous retournons un objet vide |
| PublicationAPersonneListe publicationAPersonneListe = new PublicationAPersonneListe(0); |
| if (seqId!=null) { |
| Reponse reponseRequete = new Reponse(publicationAPersonneListe, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } else { |
| vueARafraichir.rafraichir(publicationAPersonneListe); |
| } |
| } |
| } |
| }); |
| } |
| public void ajouter(String publicationId, String personnesId, String roleId, final Integer seqId) { |
| String postDonneesEncodees = "cpuap_id_publication="+URL.encodeComponent(publicationId) |
| +"&cpuap_id_auteur="+URL.encodeComponent(personnesId) |
| +"&cpuap_id_role="+URL.encodeComponent(roleId) |
| +"&cmhl_ce_modifier_par="+utilisateurId; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "ajout_publication_a_personne", seqId); |
| } |
| }); |
| } |
| public void modifier(String publicationId, String personnesId, String roleId, final Integer seqId) { |
| String[] parametres = {publicationId, personnesId, roleId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| String postDonneesEncodees = "cpuap_id_publication="+URL.encodeComponent(publicationId) |
| +"&cmhl_ce_modifier_par="+utilisateurId; |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "modif_publication_a_personne", seqId); |
| } |
| }); |
| } |
| public void supprimer(String idPublicationAPersonne) { |
| String[] parametres = {utilisateurId, idPublicationAPersonne}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isString() != null) { |
| Information info = new Information("suppression_publication_a_personne"); |
| info.setMessage(responseValue.isString().stringValue()); |
| vueARafraichir.rafraichir(info); |
| } else { |
| GWT.log(rb.getUrl()+"\n\tLa réponse n'est pas une chaine JSON.", null); |
| } |
| } |
| }); |
| } |
| private void traiterReponse(JSONValue reponseValeur, String type, Integer seqId) { |
| Information info = new Information(type); |
| // Si la requête est un succès, réception d'une chaîne |
| if (reponseValeur.isBoolean() != null) { |
| info.setDonnee(reponseValeur.isBoolean().booleanValue()); |
| } else if (reponseValeur.isString() != null) { |
| info.setDonnee(reponseValeur.isString().stringValue()); |
| } else { |
| info.setDeboguage("La réponse n'est pas une chaine JSON."); |
| } |
| if (seqId != null) { |
| Reponse retourRequete = new Reponse(info, seqId); |
| vueARafraichir.rafraichir(retourRequete); |
| } else { |
| vueARafraichir.rafraichir(info); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/publication/PublicationAPersonneAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/publication/Publication.java |
|---|
| New file |
| 0,0 → 1,132 |
| package org.tela_botanica.client.modeles.publication; |
| import org.tela_botanica.client.modeles.aDonnee; |
| import org.tela_botanica.client.modeles.structure.Structure; |
| import org.tela_botanica.client.util.UtilString; |
| import com.google.gwt.json.client.JSONObject; |
| public class Publication extends aDonnee { |
| private static final long serialVersionUID = 4142843068041690126L; |
| private static final String PREFIXE = "cpu"; |
| private Structure editeur = null; |
| public static String[] champsObligatoires = {"cpu_id_publication"}; |
| public Publication() { |
| } |
| public Publication(JSONObject publication) { |
| initialiserModele(publication); |
| editeur = new Structure(publication); |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| public void setStructureEditeur(Structure structure) { |
| editeur = structure; |
| } |
| public String getId() { |
| return renvoyerValeurCorrecte("id_publication"); |
| } |
| public void setId(String idPublication) { |
| this.set("id_publication", idPublication); |
| } |
| public String getIdProjet() { |
| return renvoyerValeurCorrecte("ce_projet"); |
| } |
| public void setIdProjet(String idProjet) { |
| this.set("ce_projet", idProjet); |
| } |
| public String getNomComplet() { |
| return renvoyerValeurCorrecte("fmt_nom_complet"); |
| } |
| public void setNomComplet(String nomComplet) { |
| this.set("fmt_nom_complet", nomComplet); |
| } |
| public String getURI() { |
| return renvoyerValeurCorrecte("uri"); |
| } |
| public void setUri(String uri) { |
| this.set("uri", uri); |
| } |
| public String getAuteur() { |
| return renvoyerValeurCorrecte("fmt_auteur"); |
| } |
| public void setAuteur(String auteurFormate) { |
| this.set("fmt_auteur", auteurFormate); |
| } |
| public String getCollection() { |
| return renvoyerValeurCorrecte("collection"); |
| } |
| public void setCollection(String collection) { |
| this.set("collection", collection); |
| } |
| public String getTitre() { |
| return renvoyerValeurCorrecte("titre"); |
| } |
| public void setTitre(String titre) { |
| this.set("titre", UtilString.ucFirst(titre)); |
| } |
| public String getNomEditeur() { |
| String editeurNom = getEditeur(); |
| if (editeurNom.matches("[0-9]+")) { |
| editeurNom = editeur.getNom(); |
| } |
| return editeurNom; |
| } |
| public String getEditeur() { |
| return getChaineDenormaliseUnique("ce_truk_editeur"); |
| } |
| public void setEditeur(String editeur) { |
| setChaineDenormaliseUnique("ce_truk_editeur", "AUTRE", editeur); |
| } |
| public String getAnneeParution() { |
| return renvoyerValeurCorrecte("date_parution").substring(0, 4); |
| } |
| public String getDateParution() { |
| return renvoyerValeurCorrecte("date_parution"); |
| } |
| public void setDateParution(String date) { |
| this.set("date_parution", date); |
| } |
| public String getIndicationNvt() { |
| return renvoyerValeurCorrecte("indication_nvt"); |
| } |
| public void setIndicationNvt(String nvt) { |
| this.set("indication_nvt", nvt); |
| } |
| public String getFascicule() { |
| return renvoyerValeurCorrecte("fascicule"); |
| } |
| public void setFascicule(String fascicule) { |
| this.set("fascicule", fascicule); |
| } |
| public String getPages() { |
| return renvoyerValeurCorrecte("truk_pages"); |
| } |
| public void setPages(String pages) { |
| this.set("truk_pages", pages); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/publication/Publication.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/publication/PublicationListe.java |
|---|
| New file |
| 0,0 → 1,123 |
| package org.tela_botanica.client.modeles.publication; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import com.google.gwt.i18n.client.Dictionary; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.aDonneeListe; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| /** |
| * Classe contenant les informations sur les Publications renvoyées par un objet de type DAO. |
| * |
| * @author Aurélien PERONNET |
| * |
| */ |
| public class PublicationListe extends aDonneeListe<Publication> implements ListePaginable { |
| private static final long serialVersionUID = 2600314321196345072L; |
| private int currentPage = 0; |
| private int nbElementsPage = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); |
| private int nbElementsTotal; |
| private Rafraichissable vueARafraichir; |
| public PublicationListe() { |
| super(); |
| } |
| public PublicationListe(int taille) { |
| super(taille); |
| } |
| public PublicationListe(JSONArray ListeDePublications) { |
| super(ListeDePublications.size()); |
| initialiserPublicationListe(ListeDePublications); |
| } |
| public PublicationListe(JSONArray ListeDePublications, JSONNumber nbElements, Rafraichissable vueARafraichir) { |
| super(ListeDePublications.size()); |
| this.nbElementsTotal = Integer.valueOf(nbElements.toString()); |
| this.vueARafraichir = vueARafraichir; |
| initialiserPublicationListe(ListeDePublications); |
| } |
| private void initialiserPublicationListe(JSONArray ListeDePublications) { |
| int taille = ListeDePublications.size(); |
| for (int i = 0; i < taille; i++) { |
| JSONObject publicationCourante = ListeDePublications.get(i).isObject() ; |
| if (publicationCourante != null) { |
| Publication publication = new Publication(publicationCourante); |
| this.put(publication.getId(), publication); |
| } |
| } |
| } |
| public void changerNumeroPage(int pageCourante) { |
| currentPage = pageCourante; |
| selectionnerPublication(); |
| } |
| public void changerTaillePage(int nouvelleTaillePage) { |
| nbElementsPage = nouvelleTaillePage; |
| selectionnerPublication(); |
| } |
| public void recharger() { |
| selectionnerPublication(); |
| } |
| public void setPageCourante(int pageCourante) { |
| this.currentPage = pageCourante; |
| } |
| public void setTaillePage(int taillePage) { |
| this.nbElementsPage = taillePage; |
| } |
| public int[] getPageTable() { |
| int[] page = new int[4]; |
| // nombre de pages au total |
| page[0] = calculerNbPages(); |
| // Page En Cours |
| page[1] = currentPage; |
| // nbElementsParPage |
| page[2] = nbElementsPage; |
| // et le dernier le nombre total d'éléments |
| page[3] = nbElementsTotal; |
| return page; |
| } |
| /** |
| * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements |
| * donnés en fonction de la taille de page en cours |
| * |
| * @return le nombre de pages |
| */ |
| public int calculerNbPages() { |
| // À cause de la bétise de java pour les conversion implicite, on fait quelques conversions manuellement |
| // pour eviter qu'il arrondisse mal la division nombre de pages = (nombre d'element / taille de la page) |
| // arrondie à l'entier supérieur. |
| double nPage = (1.0 * nbElementsTotal) / (1.0 * nbElementsPage); |
| double nPageRound = Math.ceil(nPage); |
| Double nPageInt = new Double(nPageRound); |
| // Convertion en entier |
| return nPageInt.intValue(); |
| } |
| public void selectionnerPublication() { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerPublication(vueARafraichir, mediateur.getProjetId(), null, null, currentPage, nbElementsPage, null); |
| } |
| public void filtrerParNom(String nom) { |
| Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| mediateur.selectionnerPublicationParNomComplet(vueARafraichir, mediateur.getProjetId(), "%" + nom + "%"); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/publication/PublicationListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/publication/PublicationAsyncDao.java |
|---|
| New file |
| 0,0 → 1,156 |
| package org.tela_botanica.client.modeles.publication; |
| import java.util.HashMap; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| 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.synchronisation.Reponse; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| 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 PublicationAsyncDao { |
| private static final String SERVICE_NOM = "CoelPublication"; |
| private String utilisateurId = null; |
| private Rafraichissable vueARafraichir = null; |
| public PublicationAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| if (Mediateur.DEBUG) System.out.println("|| PublicationAsyncDao > vueARafraichir = "+vueARafraichirCourrante.getClass().toString()); |
| vueARafraichir = vueARafraichirCourrante ; |
| utilisateurId = ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).getUtilisateurId(); |
| } |
| public void selectionner(final String publicationId, String projetId, String nomComplet, final int nbElements, final int pageCourante, final Integer seqId) { |
| String[] parametres = {projetId, publicationId, nomComplet}; |
| HashMap<String, String> restrictions = new HashMap<String, String>(); |
| restrictions.put("orderby", "cpu_titre"); |
| 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) { |
| // 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 |
| Publication publication = new Publication(reponse); |
| // et on met à jour le demandeur des données |
| if (seqId!=null) { |
| Reponse reponseRequete = new Reponse(publication, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } else { |
| vueARafraichir.rafraichir(publication); |
| } |
| } else if (responseArray.get(1).isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| PublicationListe publications; |
| if (reponse.get(1).isObject() != null) { |
| publications = new PublicationListe(reponse.get(1).isArray()); |
| } else { |
| publications = new PublicationListe(reponse.get(1).isArray(), reponse.get(0).isNumber(), vueARafraichir); |
| } |
| publications.setTaillePage(nbElements); |
| publications.setPageCourante(pageCourante); |
| if (seqId!=null) { |
| Reponse reponseRequete = new Reponse(publications, seqId); |
| vueARafraichir.rafraichir(reponseRequete); |
| } else { |
| vueARafraichir.rafraichir(publications); |
| } |
| } else { |
| GWT.log("La réponse n'est pas un objet ou un talbeau JSON et vaut : "+responseValue.toString(), null); |
| } |
| } else { |
| // Dans le cas, où nous demandons toutes les publication et qu'il n'y en a pas, nous retournons un objet vide |
| if (publicationId == null) { |
| PublicationListe publications = new PublicationListe(0); |
| vueARafraichir.rafraichir(publications); |
| } |
| } |
| } |
| }); |
| } |
| public void ajouter(Publication publication, final Integer seqId) { |
| String postDonneesEncodees = publication.obtenirChainePOST()+"&cmhl_ce_modifier_par="+utilisateurId; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM); |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "ajout_publication", seqId); |
| } |
| }) ; |
| } |
| public void modifier(Publication publication, final Integer seqId) { |
| String[] parametres = {publication.getId()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| String postDonneesEncodees = publication.obtenirChainePOST()+"&cmhl_ce_modifier_par="+utilisateurId; |
| rb.envoyerRequete(postDonneesEncodees, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "modif_publication", seqId); |
| } |
| }); |
| } |
| public void supprimer(String publicationsId) { |
| String[] parametres = {utilisateurId, publicationsId}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequetePost(SERVICE_NOM, parametres); |
| rb.envoyerRequeteSuppression(new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue reponseValeur) { |
| traiterReponse(reponseValeur, "suppression_publication", null); |
| } |
| }); |
| } |
| private void traiterReponse(JSONValue reponseValeur, String type, Integer seqId) { |
| Information info = new Information(type); |
| // Si la requête est un succès, réception d'une chaîne |
| if (reponseValeur.isString() != null) { |
| String idOuMessage = reponseValeur.isString().stringValue(); |
| if (idOuMessage.matches("^[0-9]+$")) { |
| info.setDonnee(idOuMessage); |
| } else { |
| info.setMessage(idOuMessage); |
| } |
| } else { |
| info.setDeboguage("La réponse n'est pas une chaine JSON."); |
| } |
| if (seqId!=null) { |
| Reponse retourRequete = new Reponse(info, seqId); |
| vueARafraichir.rafraichir(retourRequete); |
| } else { |
| vueARafraichir.rafraichir(info); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/publication/PublicationAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/UtilisateurAsyncDao.java |
|---|
| New file |
| 0,0 → 1,175 |
| package org.tela_botanica.client.modeles; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.http.JsonRestRequestBuilder; |
| import org.tela_botanica.client.http.JsonRestRequestCallback; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.UtilDAO; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.extjs.gxt.ui.client.widget.Info; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.http.client.Request; |
| import com.google.gwt.http.client.RequestBuilder; |
| import com.google.gwt.http.client.RequestCallback; |
| import com.google.gwt.http.client.RequestException; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONBoolean; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.Window; |
| /** |
| * Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour |
| * |
| */ |
| public class UtilisateurAsyncDao { |
| private static final String SERVICE_NOM = "CoelUtilisateur"; |
| private Utilisateur utilisateur = null; |
| private Rafraichissable vueARafraichir = null; |
| /** |
| * Constructeur |
| * @param retour : méthode appellée en retour d'appel. |
| */ |
| public UtilisateurAsyncDao(Rafraichissable vueARafraichirCourrante) { |
| vueARafraichir = vueARafraichirCourrante; |
| utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT); |
| } |
| /** |
| * Méthode de classe d'appel du service des gestion d'identification. |
| */ |
| public void getEtatUtilisateur() { |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // Identifiant utilisateur ou identifiant de session si non identifié |
| String login = ((JSONString) reponse.get(2)).stringValue(); |
| // Drapeau leve si utilisateur deja identifié |
| boolean identifie = ((JSONBoolean) reponse.get(3)).booleanValue(); |
| utilisateur.setIdentification(identifie); |
| utilisateur.setLogin(login); |
| vueARafraichir.rafraichir(utilisateur); |
| } |
| } |
| }); |
| } |
| /** |
| * Méthode déconnectant un utilisateur de l'application. |
| * @param identifiant de l'utilisateur à déconnecter. |
| */ |
| public void deconnecterUtilisateur() { |
| String[] parametres = {utilisateur.getId()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // Identifiant utilisateur ou identifiant de session si non identifié |
| String id = ((JSONString) reponse.get(1)).stringValue(); |
| // Drapeau levé si l'utilisateur est déjà identifié |
| boolean identifie = ((JSONBoolean) reponse.get(2)).booleanValue(); |
| // Nous réinitialisons l'utilisateur |
| utilisateur = new Utilisateur(id, identifie); |
| GWT.log(utilisateur.toString(), null); |
| vueARafraichir.rafraichir(utilisateur); |
| } |
| } |
| }); |
| } |
| /** |
| * Méthode connectant un utilisateur à l'application. |
| * @param Utilisateur l'utilisateur courant. |
| */ |
| public void connecterUtilisateur() { |
| String[] parametres = {utilisateur.getLogin(), utilisateur.getMotDePasse()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| //Ajout des informations licence |
| if (reponse.get(0).isString() != null) { |
| utilisateur.setLicence(reponse.get(0).isString().stringValue()); |
| } else { |
| utilisateur.setLicence(""); |
| } |
| if (reponse.size() > 0) { |
| // Identifiant de l'utilisateur ou identifiant de session si non identifié |
| utilisateur.setId(((JSONString) reponse.get(1)).stringValue()); |
| // Drapeau levé si l'utilisateur est déjà identifié |
| utilisateur.setIdentification(((JSONBoolean) reponse.get(2)).booleanValue()); |
| // Plus de deux valeurs, l'utilisateur est identifié nous récupérons des données supplémentaires |
| if (reponse.size() > 3) { |
| // Nom complet de l'utilisateur |
| if (reponse.get(3).isString() != null) { |
| utilisateur.setNomComplet(((JSONString) reponse.get(3)).stringValue()); |
| } |
| // Prénom de l'utilisateur |
| if (reponse.get(4).isString() != null) { |
| utilisateur.setPrenom(((JSONString) reponse.get(4)).stringValue()); |
| } |
| // Nom de l'utilisateur |
| if (reponse.get(5).isString() != null) { |
| utilisateur.setNom(((JSONString) reponse.get(5)).stringValue()); |
| } |
| // Paramètres |
| if (reponse.get(6).isString() != null) { |
| utilisateur.setParametre(((JSONString) reponse.get(6)).stringValue()); |
| } |
| } |
| vueARafraichir.rafraichir(utilisateur); |
| } |
| } |
| } |
| }); |
| } |
| /* |
| * */ |
| public void accepterLicence() { |
| String[] parametres = {utilisateur.getLogin(), utilisateur.getMotDePasse(), utilisateur.getId()}; |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| 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); |
| } |
| } |
| } |
| }); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/UtilisateurAsyncDao.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/Valeur.java |
|---|
| New file |
| 0,0 → 1,116 |
| package org.tela_botanica.client.modeles; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| import org.tela_botanica.client.util.Debug; |
| import com.extjs.gxt.ui.client.data.ModelData; |
| import com.google.gwt.json.client.JSONObject; |
| public class Valeur extends aDonnee { |
| private static final long serialVersionUID = 2278245640718653819L; |
| public static final String PREFIXE = "cmlv"; |
| public static final String COLLECTION_NCD_HERBIER = "2157"; |
| public static String[] champsObligatoires = {"cmlv_id_valeur"}; |
| public Valeur() { |
| } |
| public Valeur(JSONObject liste) { |
| // l'objet JSON est une table de hachage |
| Set<String> im = liste.keySet(); |
| // Parcourt pour chaque clé |
| for (Iterator<String> it = im.iterator(); it.hasNext();) { |
| // Si elle est associée à une valeur, nous l'ajoutons |
| String cle = it.next(); |
| // Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet |
| String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", ""); |
| if (liste.get(cle).isString() != null) { |
| String valeur = liste.get(cle).isString().stringValue(); |
| this.set(cleObjet, valeur); |
| } else { |
| // Sinon, nous ajoutons la clé avec une valeur vide |
| String valeur = " "; |
| this.set(cleObjet, valeur); |
| } |
| } |
| } |
| public Valeur(String id, String nom, String abr, String description) { |
| this.set("id_valeur", id); |
| this.set("nom", nom); |
| this.set("abreviation", abr); |
| this.set("description", description); |
| } |
| public Valeur(ModelData model) |
| { |
| Map<String, Object> a = model.getProperties(); |
| Set<String> cles = a.keySet(); |
| Iterator<String> it = cles.iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| if (a.get(cle) != null) { |
| String cleObjet = cle.replaceFirst("^"+getPrefixe()+"_", ""); |
| this.set(cleObjet, a.get(cle)); |
| } |
| } |
| } |
| @Override |
| protected String getPrefixe() { |
| return PREFIXE; |
| } |
| protected String[] getChampsObligatoires() { |
| return champsObligatoires; |
| } |
| /** Accesseur à l'identifiant de la valeur. |
| * |
| * @return String l'identifiant de la valeur. |
| */ |
| public String getId() { |
| return (String) renvoyerValeurCorrecte("id_valeur"); |
| } |
| /** Accesseur au nom de la valeur. |
| * |
| * @return String le nom de la valeur. |
| */ |
| public String getNom() { |
| return (String) renvoyerValeurCorrecte("nom"); |
| } |
| /** Accesseur à l'abréviation de la valeur. |
| * |
| * @return String l'abréviation de la valeur. |
| */ |
| public String getAbreviation() { |
| return (String) renvoyerValeurCorrecte("abreviation"); |
| } |
| /** Accesseur à la description de la valeur. |
| * |
| * @return String la description de la valeur. |
| */ |
| public String getDescription() { |
| return (String) renvoyerValeurCorrecte("description"); |
| } |
| /** Accesseur à l'identifiant parent de la valeur. |
| * |
| * @return String l'identifiant de la valeur. |
| */ |
| public String getParentId() { |
| return (String) renvoyerValeurCorrecte("ce_parent"); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/Valeur.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/ValeurListe.java |
|---|
| New file |
| 0,0 → 1,141 |
| package org.tela_botanica.client.modeles; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import org.tela_botanica.client.Mediateur; |
| import org.tela_botanica.client.RegistreId; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.util.Debug; |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.i18n.client.Dictionary; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONString; |
| /** |
| * Table de hachage composée d'informations sur les Valeurs des listes, renvoyé par un objet de type DAO |
| * La clé est le nom de l'entite + le nom de l'entite parente |
| * |
| * @author david delon |
| * |
| */ |
| public class ValeurListe extends aDonneeListe<Valeur> { |
| /** |
| * Identifiant pour sérialisé l'objet... |
| */ |
| private static final long serialVersionUID = 7784635999621813450L; |
| private Mediateur mediateur = (Mediateur) Registry.get(RegistreId.MEDIATEUR); |
| private int nbElementsTotal; |
| // Id de la meta-liste dans la base de données |
| private int id = 0; |
| private String abv = ""; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public ValeurListe() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * @param taille la taille de la table de hachage |
| */ |
| public ValeurListe(int taille) { |
| super(taille); |
| } |
| /** |
| * Constructeur pour une liste d'institutions |
| * @param dates |
| */ |
| public ValeurListe(JSONArray liste) { |
| super(liste.size()); |
| this.constuireObjet(liste); |
| } |
| public ValeurListe(JSONString listeId, JSONArray listeValeurs) { |
| super(listeValeurs.size()); |
| this.setId(Integer.parseInt(listeId.stringValue())); |
| this.constuireObjet(listeValeurs); |
| } |
| public ValeurListe(JSONString listeId, String abv, JSONArray listeValeurs, JSONNumber nbElements) { |
| super(listeValeurs.size()); |
| this.setId(Integer.parseInt(listeId.stringValue())); |
| this.abv = abv; |
| this.setNbElementsTotal(nbElements.toString()); |
| this.constuireObjet(listeValeurs); |
| } |
| protected void constuireObjet(JSONArray liste) { |
| final int taillemax = liste.size(); |
| for (int i = 0; i < taillemax; i++) { |
| JSONObject listeValeur = liste.get(i).isObject(); |
| if (listeValeur != null) { |
| Valeur valeur = new Valeur(listeValeur); |
| this.put(valeur.getId(), valeur); |
| } |
| } |
| } |
| /** |
| * @param id l'identifiant à définir |
| */ |
| public void setId(int id) { |
| this.id = id; |
| } |
| public void setNbElementsTotal(String nbElements) { |
| this.nbElementsTotal = Integer.parseInt(nbElements); |
| } |
| /** |
| * @return l'identifiant de la liste |
| */ |
| public Integer getId() { |
| return id; |
| } |
| public String getFullId() { |
| return (id+abv); |
| } |
| public void ajouter(Valeur val) { |
| this.put(val.getId(), val); |
| } |
| public ValeurListe cloner() |
| { |
| ValeurListe l = new ValeurListe(); |
| Iterator i = this.keySet().iterator(); |
| while (i.hasNext()) |
| { |
| String clef = (String)i.next(); |
| Valeur valeur = this.get(clef); |
| l.put(clef, valeur); |
| } |
| return l; |
| } |
| public void concatenerListe(ValeurListe lv) { |
| this.putAll(lv); |
| this.setId(lv.getId()); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles/ValeurListe.java:r1136-1368 |
| /trunk/src/org/tela_botanica/client/modeles/. |
|---|
| New file |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/modeles:r1136-1328 |