WebSVN – eFlore/Applications.coel – Diff – /trunk/src/org/tela_botanica/client/modeles/aDonnee.java


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));
			}
		}
	}
}

Subversion Repositories eFlore/Applications.coel

(root)/trunk/src/org/tela_botanica/client/modeles/aDonnee.java – Rev 1292 → 1369

Rev 1292		Rev 1369
1	`package org.tela_botanica.client.modeles;`	1	`package org.tela_botanica.client.modeles;`
2		2
3	`import java.io.Serializable;`	3	`import java.io.Serializable;`
4	`import java.util.Arrays;`	4	`import java.util.Arrays;`
5	`import java.util.Collection;`	5	`import java.util.Collection;`
6	`import java.util.HashMap;`	6	`import java.util.HashMap;`
7	`import java.util.Iterator;`	7	`import java.util.Iterator;`
8	`import java.util.LinkedList;`	8	`import java.util.LinkedList;`
9	`import java.util.List;`	9	`import java.util.List;`
10	`import java.util.Map;`	10	`import java.util.Map;`
11	`import java.util.Set;`	11	`import java.util.Set;`
12	`import java.util.TreeSet;`	12	`import java.util.TreeSet;`
13		13
14	`import org.tela_botanica.client.util.Debug;`	14	`import org.tela_botanica.client.util.Debug;`
15	`import org.tela_botanica.client.util.UtilArray;`	15	`import org.tela_botanica.client.util.UtilArray;`
-		16	`import org.tela_botanica.client.util.UtilString;`
16		17
17	`import com.extjs.gxt.ui.client.core.FastMap;`	18	`import com.extjs.gxt.ui.client.core.FastMap;`
18	`import com.extjs.gxt.ui.client.data.BaseModelData;`	19	`import com.extjs.gxt.ui.client.data.BaseModelData;`
19	`import com.google.gwt.core.client.GWT;`	20	`import com.google.gwt.core.client.GWT;`
20	`import com.google.gwt.http.client.URL;`	21	`import com.google.gwt.http.client.URL;`
21	`import com.google.gwt.json.client.JSONObject;`	22	`import com.google.gwt.json.client.JSONObject;`
22		23
23	`/**`	24	`/**`
24	`* @author jpm`	25	`* @author jpm`
25	`*`	26	`*`
26	`*/`	27	`*/`
27	`public abstract class aDonnee extends BaseModelData implements Serializable {`	28	`public abstract class aDonnee extends BaseModelData implements Serializable {`
28		29
29	`private static final long serialVersionUID = 3527760464061629791L;`	30	`private static final long serialVersionUID = 3527760464061629791L;`
30		31
31	`public static final String TYPE_AUTRE = "AUTRE";`	32	`public static final String TYPE_AUTRE = "AUTRE";`
32	`public static final String TYPE_TOTAL = "TOTAL";`	33	`public static final String TYPE_TOTAL = "TOTAL";`
33	`public static final String SEPARATEUR_TYPE_VALEUR = "##";`	34	`public static final String SEPARATEUR_TYPE_VALEUR = "##";`
34	`public static final String SEPARATEUR_VALEURS = ";;";`	35	`public static final String SEPARATEUR_VALEURS = ";;";`
35	`public static final String SEPARATEUR_DONNEES = "\|\|";`	36	`public static final String SEPARATEUR_DONNEES = "\|\|";`
36	`public static final String ETAT_AJOUTE = "A";`	37	`public static final String ETAT_AJOUTE = "A";`
37	`public static final Object ETAT_MODIFIE = "M";`	38	`public static final Object ETAT_MODIFIE = "M";`
38	`public static final String VALEUR_NULL = "NC";`	39	`public static final String VALEUR_NULL = "NC";`
39	`public HashMap<String, String> valeursInitiales = new HashMap<String, String>();`	40	`public HashMap<String, String> valeursInitiales = new HashMap<String, String>();`