Subversion Repositories eFlore/Applications.coel

Rev

Rev 1613 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
69 jpm 1 
package org.tela_botanica.client.modeles;
2 
 
3 
import java.io.Serializable;
1173 jpm 4 
import java.util.Arrays;
385 gduche 5 
import java.util.Collection;
248 gduche 6 
import java.util.HashMap;
193 jp_milcent 7 
import java.util.Iterator;
248 gduche 8 
import java.util.LinkedList;
306 jp_milcent 9 
import java.util.Map;
193 jp_milcent 10 
import java.util.Set;
306 jp_milcent 11 
import java.util.TreeSet;
69 jpm 12 
 
233 jp_milcent 13 
import org.tela_botanica.client.util.UtilArray;
1369 cyprien 14 
import org.tela_botanica.client.util.UtilString;
233 jp_milcent 15 
 
534 gduche 16 
import com.extjs.gxt.ui.client.core.FastMap;
69 jpm 17 
import com.extjs.gxt.ui.client.data.BaseModelData;
385 gduche 18 
import com.google.gwt.http.client.URL;
775 jpm 19 
import com.google.gwt.json.client.JSONObject;
69 jpm 20 
 
193 jp_milcent 21 
/**
22 
 * @author jpm
23 
 *
24 
 */
69 jpm 25 
public abstract class aDonnee extends BaseModelData implements Serializable {
26 
 
27 
	private static final long serialVersionUID = 3527760464061629791L;
748 jpm 28 
 
1573 jpm 29 
	public static final boolean SUPPRIMER_PREFIXE = true;
30 
	public static final boolean GARDER_PREFIXE = false;
31 
	public static final boolean INTEGRER_PROPRIETES = true;
789 jpm 32 
	public static final String TYPE_AUTRE = "AUTRE";
33 
	public static final String TYPE_TOTAL = "TOTAL";
34 
	public static final String SEPARATEUR_TYPE_VALEUR = "##";
35 
	public static final String SEPARATEUR_VALEURS = ";;";
36 
	public static final String SEPARATEUR_DONNEES = "||";
875 jpm 37 
	public static final String ETAT_AJOUTE = "A";
883 jpm 38 
	public static final Object ETAT_MODIFIE = "M";
1042 gduche 39 
	public static final String VALEUR_NULL = "NC";
1561 jpm 40 
 
1257 gduche 41 
	public HashMap<String, String> valeursInitiales = new HashMap<String, String>();
1561 jpm 42 
	protected boolean removePrefix = true;
43 
 
748 jpm 44 
	protected abstract String getPrefixe();
1173 jpm 45 
	protected abstract String[] getChampsObligatoires();
748 jpm 46 
 
789 jpm 47 
	public String getDateModification() {
48 
		return (String) renvoyerValeurCorrecte("cmhl_date_modification");
49 
	}
50 
 
51 
	public String getNotes() {
52 
		return (String) renvoyerValeurCorrecte("cmhl_notes");
53 
	}
54 
 
55 
	public String getIdModifierPar() {
56 
		return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");
57 
	}
58 
 
59 
	public String getIdEtat() {
60 
		return (String) renvoyerValeurCorrecte("cmhl_ce_etat");
61 
	}
62 
 
63 
	public String getIp() {
64 
		return (String) renvoyerValeurCorrecte("cmhl_ip");
65 
	}
66 
 
775 jpm 67 
	protected void initialiserModele(JSONObject jsonObjet) {
68 
		// l'objet JSON est une table de hachage
69 
		Set<String> im = jsonObjet.keySet();
1173 jpm 70 
		valeursInitiales = new HashMap<String, String>();
71 
 
775 jpm 72 
		// Parcourt pour chaque clé
73 
		for (Iterator<String> it = im.iterator(); it.hasNext();) {
74 
			// Si elle est associée à une valeur, nous l'ajoutons
75 
			String cle = it.next();
1173 jpm 76 
			if (cle.startsWith(getPrefixe()+"_") ||cle.matches("^_.+_$")) {
775 jpm 77 
				// Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet
78 
				String cleObjet = cle.replaceFirst("^"+getPrefixe()+"_", "");
79 
				// Sinon, nous ajoutons la clé avec une valeur vide
80 
				String valeur = "";
81 
				if (jsonObjet.get(cle).isString() != null) {
82 
					valeur = jsonObjet.get(cle).isString().stringValue();
83 
				}
1173 jpm 84 
				valeursInitiales.put(cleObjet, valeur);
775 jpm 85 
				this.set(cleObjet, valeur);
1173 jpm 86 
			}
775 jpm 87 
		}
88 
	}
89 
 
1569 jpm 90 
	public void setValeurInitiale(String cleObjet, String valeur) {}
1561 jpm 91 
 
69 jpm 92 
	/**
93 
	 * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par
94 
	 * cette fonction qui retire les charactères nuls qui font planter
1561 jpm 95 
	 * l'affichage, il ne faut pas utiliser get directement.
96 
	 * Elle ajoute aussi le préfixe au nom du champ si nécessaire.
69 jpm 97 
	 *
1561 jpm 98 
	 * @param cle le nom du champ sans le préfixe.
69 jpm 99 
	 * @return la valeur associée à la clé
100 
	 */
193 jp_milcent 101 
	protected String renvoyerValeurCorrecte(String cle) {
188 jp_milcent 102 
		String sortie = "";
1573 jpm 103 
		cle = gererPrefixe(cle);
69 jpm 104 
		if (this.get(cle) != null) {
891 aurelien 105 
			String valeur = ""+this.get(cle);
188 jp_milcent 106 
			if (! valeur.equals("null")) {
69 jpm 107 
				char nullChar = '\u0000';
108 
				String sNull = "" + nullChar;
109 
				valeur = valeur.replaceAll(sNull, "");
188 jp_milcent 110 
				sortie =  valeur;
69 jpm 111 
			}
112 
		}
891 aurelien 113 
 
188 jp_milcent 114 
		return sortie;
69 jpm 115 
	}
233 jp_milcent 116 
 
193 jp_milcent 117 
	/**
1561 jpm 118 
	 * Ajoute le préfixe au nom du champ si nécessaire.
119 
	 *
120 
	 * @param la clé du champ
121 
	 * @param la valeur associé à la clé
122 
	 */
123 
	protected void setValeurCorrecte(String cle, String valeur) {
1573 jpm 124 
		cle = gererPrefixe(cle);
1561 jpm 125 
		set(cle, valeur);
126 
	}
127 
 
128 
	/**
242 jp_milcent 129 
	 * Ajoute un nouvel élément avec son type à une chaine dénormalisée.
130 
	 * Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".
131 
	 * Si l'élément existe déjà, il ne sera pas ajouté.
193 jp_milcent 132 
	 *
133 
	 * @param champ le nom du champ dénormalisé
134 
	 * @param type le type de la valeur à ajouter
135 
	 * @param valeur la valeur à ajouter
136 
	 */
242 jp_milcent 137 
	protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {
193 jp_milcent 138 
		if (valeur instanceof String) {
139 
			String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 140 
			if (UtilString.isEmpty(chaineExistante)) {
789 jpm 141 
				this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur);
193 jp_milcent 142 
			} else {
242 jp_milcent 143 
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
789 jpm 144 
				if (!chaineExistante.matches("(^|"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+valeur+"("+SEPARATEUR_VALEURS+"|$)")) {
145 
					this.set(champ, chaineExistante+";;"+type+SEPARATEUR_TYPE_VALEUR+valeur);
242 jp_milcent 146 
				}
193 jp_milcent 147 
			}
148 
		}
149 
	}
119 jpm 150 
 
306 jp_milcent 151 
	protected void supprimerTypeDansChaineDenormalise(String champ, String type) {
152 
		String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 153 
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 154 
			if (chaineExistante.matches("(?:^|.*"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+".*")) {
155 
				chaineExistante = chaineExistante.replaceFirst("(^|.*"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+".*?("+SEPARATEUR_VALEURS+".*|$)", "$1$2");
156 
				chaineExistante = chaineExistante.replaceAll("(.*)"+SEPARATEUR_VALEURS+SEPARATEUR_VALEURS+"(.*)", "$1"+SEPARATEUR_VALEURS+"$2");
157 
				chaineExistante = chaineExistante.replaceAll("^"+SEPARATEUR_VALEURS+"(.*)", "$1");
158 
				chaineExistante = chaineExistante.replaceAll("(.*)"+SEPARATEUR_VALEURS+"$", "$1");
306 jp_milcent 159 
				this.set(champ, chaineExistante);
160 
			}
161 
		}
162 
	}
163 
 
164 
	protected void remplacerTypeDansChaineDenormalise(String champ, String type, Object valeur) {
165 
		if (valeur != null && !valeur.equals("")) {
166 
			ajouterChaineDenormaliseAvecType(champ, type, valeur);
167 
		} else {
168 
			supprimerTypeDansChaineDenormalise(champ, type);
169 
		}
170 
	}
1569 jpm 171 
 
233 jp_milcent 172 
	/**
242 jp_milcent 173 
	 * Ajoute un nouvel élément sans type à une chaine dénormalisée.
174 
	 * Champ de type "truk" contenant seulement des valeurs séparées par ";;".
175 
	 * Si l'élément existe déjà, il ne sera pas ajouté.
176 
	 *
177 
	 * @param champ le nom du champ dénormalisé
178 
	 * @param valeur la valeur à ajouter
179 
	 */
180 
	protected void ajouterChaineDenormalise(String champ, Object valeur) {
181 
		if (valeur instanceof String) {
182 
			String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 183 
			if (UtilString.isEmpty(chaineExistante)) {
242 jp_milcent 184 
				this.set(champ, valeur);
185 
			} else {
186 
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
789 jpm 187 
				if (!chaineExistante.matches("(^|"+SEPARATEUR_VALEURS+")"+valeur+"("+SEPARATEUR_VALEURS+"|$)")) {
188 
					this.set(champ, chaineExistante+SEPARATEUR_VALEURS+valeur);
242 jp_milcent 189 
				}
190 
			}
191 
		}
192 
	}
193 
 
194 
	/**
233 jp_milcent 195 
	 * Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").
196 
	 *
197 
	 * @param champ le nom du champ dénormalisé
198 
	 * @param type le type de la valeur à ajouter
199 
	 * @param valeur la valeur à ajouter
200 
	 */
793 jpm 201 
	protected void setChaineDenormaliseUnique(String champ, String type, String valeur) {
1573 jpm 202 
		champ = gererPrefixe(champ);
1369 cyprien 203 
		if (valeur == null || UtilString.isEmpty(valeur)) {
608 jp_milcent 204 
			this.set(champ, "");
205 
		} else if (valeur instanceof String) {
793 jpm 206 
			if (((String) valeur).matches("^[0-9]+$")) {
207 
				this.set(champ, valeur);
208 
			} else {
209 
				this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur);
210 
			}
233 jp_milcent 211 
		}
212 
	}
213 
 
1573 jpm 214 
	private String gererPrefixe(String champ) {
215 
		String champMisAJour = null;
216 
		String prefixe = getPrefixe()+"_";
217 
		if (removePrefix) {
218 
			champMisAJour = champ.replaceFirst(prefixe, "");
219 
		} else {
220 
			champMisAJour = (champ.startsWith(prefixe)) ? champ : prefixe+champ ;
221 
		}
222 
		return champMisAJour;
223 
	}
224 
 
245 jp_milcent 225 
	/**
226 
	 * Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").
227 
	 *
228 
	 * @param champ le nom du champ dénormalisé
229 
	 */
230 
	protected String getChaineDenormaliseUnique(String champ) {
793 jpm 231 
		String valeur = renvoyerValeurCorrecte(champ);
245 jp_milcent 232 
 
1369 cyprien 233 
		if (!UtilString.isEmpty(valeur)) {
793 jpm 234 
			valeur = valeur.replaceFirst("^"+TYPE_AUTRE+SEPARATEUR_TYPE_VALEUR, "");
245 jp_milcent 235 
		}
236 
 
793 jpm 237 
		return valeur;
245 jp_milcent 238 
	}
239 
 
208 jp_milcent 240 
	protected String getInfoDenormaliseParType(String chaineExistante, String type) {
241 
		String sortie = "";
1369 cyprien 242 
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 243 
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
208 jp_milcent 244 
			for (int i = 0; i < valeurs.length; i++) {
789 jpm 245 
				if (valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
246 
					sortie =  valeurs[i].replaceFirst("^"+type+SEPARATEUR_TYPE_VALEUR, "");
208 jp_milcent 247 
				}
248 
			}
249 
		}
250 
		return sortie;
251 
	}
252 
 
233 jp_milcent 253 
	/**
248 gduche 254 
	 * Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur
255 
	 *
256 
	 * @param champ le nom du champ dénormalisé
257 
	 * @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)
258 
	 */
259 
	public Object getChaineDenormaliseAsMapOrList(String champ)	{
260 
 
261 
			Object retourObjet = null;
262 
 
263 
			String valeurChamp = renvoyerValeurCorrecte(champ);
252 gduche 264 
 
265 
			if ((valeurChamp!=null)&&(!valeurChamp.trim().equals("")))	{
789 jpm 266 
				String[] valeurs = valeurChamp.split(SEPARATEUR_VALEURS);
252 gduche 267 
 
268 
				if (valeurs.length > 0)	{
789 jpm 269 
					if (valeurs[0].contains(SEPARATEUR_TYPE_VALEUR))	{
252 gduche 270 
						// Les champs sont typés, on en fait une Map
748 jpm 271 
						HashMap<String,String> mapValeurs = new HashMap<String,String>();
252 gduche 272 
						for (int i = 0; i < valeurs.length; i++)	{
789 jpm 273 
							String typeEtValeur[] = valeurs[i].split(SEPARATEUR_TYPE_VALEUR);
274 
							mapValeurs.put(typeEtValeur[1], typeEtValeur[0]);
252 gduche 275 
						}
276 
						retourObjet = mapValeurs;
248 gduche 277 
					}
252 gduche 278 
					else	{
279 
 
280 
						//Les champs ne sont pas typés, on en fait une Liste
748 jpm 281 
						LinkedList<String> listeValeurs = new LinkedList<String>();
252 gduche 282 
						for (int i = 0; i < valeurs.length; i++)	{
283 
							if ((valeurs[i]!=null)&&(!valeurs[i].equals("")))	{
284 
								listeValeurs.add(valeurs[i]);
285 
							}
249 gduche 286 
						}
252 gduche 287 
						retourObjet = listeValeurs;
248 gduche 288 
					}
252 gduche 289 
 
248 gduche 290 
				}
291 
			}
292 
 
293 
			return retourObjet;
294 
 
295 
	}
296 
 
297 
	/**
233 jp_milcent 298 
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
299 
	 * Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.
602 jp_milcent 300 
	 * Si aucun type n'est trouvé, nous en ajoutons un avec la nouvelle valeur.
233 jp_milcent 301 
	 *
302 
	 * @param champ le nom du champ dénormalisé
303 
	 * @param type le type de la valeur à modifier
304 
	 * @param valeur la valeur pour le type en question
305 
	 */
242 jp_milcent 306 
	protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {
608 jp_milcent 307 
		if (valeur == null || valeur.equals("")) {
602 jp_milcent 308 
			supprimerTypeDansChaineDenormalise(champ, type);
309 
		} else if (valeur instanceof String) {
233 jp_milcent 310 
			String chaineExistante = renvoyerValeurCorrecte(champ);
602 jp_milcent 311 
 
1369 cyprien 312 
			if (UtilString.isEmpty(chaineExistante)) {
789 jpm 313 
				this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur);
233 jp_milcent 314 
			} else {
789 jpm 315 
				String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
602 jp_milcent 316 
				HashMap<String,String> valeursModifiees = new HashMap<String,String>();
233 jp_milcent 317 
				for (int i = 0; i < valeurs.length; i++) {
789 jpm 318 
					if (valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
319 
						valeursModifiees.put(type, type+SEPARATEUR_TYPE_VALEUR+valeur);
320 
					} else if (i == (valeurs.length -1) && !valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
321 
						valeursModifiees.put(valeurs[i].split(SEPARATEUR_TYPE_VALEUR)[0], valeurs[i]);
322 
						valeursModifiees.put(type, type+SEPARATEUR_TYPE_VALEUR+valeur);
602 jp_milcent 323 
					} else {
789 jpm 324 
						valeursModifiees.put(valeurs[i].split(SEPARATEUR_TYPE_VALEUR)[0], valeurs[i]);
233 jp_milcent 325 
					}
326 
				}
602 jp_milcent 327 
				String[] tableauValeursModifiees = valeursModifiees.values().toArray(new String[valeursModifiees.size()]);
789 jpm 328 
				this.set(champ, UtilArray.implode(tableauValeursModifiees, SEPARATEUR_VALEURS));
233 jp_milcent 329 
			}
330 
		}
331 
	}
332 
 
208 jp_milcent 333 
	protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {
334 
		String sortie = "";
1369 cyprien 335 
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 336 
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
208 jp_milcent 337 
			if (valeurs.length >= position) {
338 
				for (int i = 0; i < valeurs.length; i++) {
339 
					if (i == (position - 1)) {
789 jpm 340 
						if (valeurs[i].contains(SEPARATEUR_TYPE_VALEUR)) {
341 
							sortie = valeurs[i].replaceFirst("^[^#]+"+SEPARATEUR_VALEURS, "");
208 jp_milcent 342 
						} else {
603 jp_milcent 343 
							sortie = valeurs[i];
208 jp_milcent 344 
						}
345 
						break;
346 
					}
347 
				}
348 
			}
349 
		}
350 
		return sortie;
351 
	}
352 
 
233 jp_milcent 353 
	/**
354 
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
355 
	 * Remplace par la valeur l'instance dont la position a été indiquée.
242 jp_milcent 356 
	 * Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.
357 
	 * Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.
233 jp_milcent 358 
	 *
359 
	 * @param champ le nom du champ dénormalisé
360 
	 * @param position le type de la valeur à modifier
361 
	 * @param valeur la valeur à remplacer à la position indiquée
362 
	 */
242 jp_milcent 363 
	protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {
608 jp_milcent 364 
		if (valeur == null || valeur.equals("")) {
603 jp_milcent 365 
			supprimerChaineDenormaliseParPosition(champ, position);
366 
		} else if (valeur instanceof String) {
233 jp_milcent 367 
			String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 368 
			if (UtilString.isEmpty(chaineExistante)) {
603 jp_milcent 369 
				this.set(champ, valeur);
370 
			} else {
789 jpm 371 
				String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
603 jp_milcent 372 
				if (valeurs.length >= position) {
233 jp_milcent 373 
					for (int i = 0; i < valeurs.length; i++) {
374 
						if (i == (position - 1)) {
375 
							valeurs[i] = (String) valeur;
376 
							break;
377 
						}
378 
					}
789 jpm 379 
					this.set(champ, UtilArray.implode(valeurs, SEPARATEUR_VALEURS));
233 jp_milcent 380 
				}
381 
			}
382 
		}
383 
	}
384 
 
603 jp_milcent 385 
	protected void supprimerChaineDenormaliseParPosition(String champ, int position) {
386 
		String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 387 
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 388 
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
603 jp_milcent 389 
			HashMap<String,String> valeursModifiees = new HashMap<String,String>();
390 
			if (valeurs.length >= position) {
391 
				for (int i = 0; i < valeurs.length; i++) {
392 
					if (i != (position - 1)) {
393 
						valeursModifiees.put(""+i, valeurs[i]);
394 
					}
395 
				}
396 
				String[] tableauValeursModifiees = valeursModifiees.values().toArray(new String[valeursModifiees.size()]);
789 jpm 397 
				this.set(champ, UtilArray.implode(tableauValeursModifiees, SEPARATEUR_VALEURS));
603 jp_milcent 398 
			}
399 
		}
400 
	}
401 
 
193 jp_milcent 402 
	/** (non-Javadoc)
403 
	 * @see java.lang.Object#toString()
404 
	 */
405 
	public String toString() {
406 
		String sortie = "";
407 
 
408 
		// Champs du BaseModelData
409 
		Set<String> proprietes = this.getProperties().keySet();
306 jp_milcent 410 
		TreeSet<String> proprietesTriees = new TreeSet<String>(proprietes);
411 
		for (Iterator<String> it = proprietesTriees.iterator(); it.hasNext();) {
193 jp_milcent 412 
			String cle = it.next();
306 jp_milcent 413 
			if (this.get(cle) != null && !this.get(cle).equals("")) {
949 jpm 414 
				sortie += cle+" : "+this.get(cle).toString()+"\n";
202 jp_milcent 415 
			}
193 jp_milcent 416 
		}
417 
 
418 
		return sortie;
419 
	}
306 jp_milcent 420 
 
421 
	public Boolean comparer(BaseModelData objetAComparer) {
422 
		Boolean retour = true;
423 
		Map<String, Object> a = this.getProperties();
424 
		Map<String, Object> b = objetAComparer.getProperties();
425 
		if (a.size() != b.size()) {
426 
			retour = false;
427 
		} else {
428 
			Set<String> cles = a.keySet();
429 
			Iterator<String> it = cles.iterator();
430 
			while (it.hasNext()) {
431 
				String cle = it.next();
432 
				if (a.get(cle) != null && !a.get(cle).equals(b.get(cle))) {
433 
					retour = false;
434 
					break;
435 
				}
436 
			}
437 
		}
438 
		return retour;
439 
	}
440 
 
441 
	public Object cloner(BaseModelData nouvelleInstance) {
442 
		Map<String, Object> proprietes = this.getProperties();
443 
		Set<String> cles = proprietes.keySet();
444 
		for (Iterator<String> it = cles.iterator(); it.hasNext();) {
445 
			String cle = it.next();
446 
			nouvelleInstance.set(cle, this.get(cle));
447 
		}
448 
 
449 
		return nouvelleInstance;
450 
	}
385 gduche 451 
 
452 
	/**
748 jpm 453 
	 * Renvoie une chaîne de caractère formatée et encodée pour POST avec toutes les propriétés du modèle
385 gduche 454 
	 * */
748 jpm 455 
	public String obtenirChainePOST() {
456 
		String post = "";
385 gduche 457 
 
748 jpm 458 
		FastMap<?> proprietees = (FastMap<?>) getProperties();
459 
		Collection<String> cles = proprietees.keySet();
460 
		Iterator<String> it = cles.iterator();
385 gduche 461 
 
462 
		while (it.hasNext())	{
748 jpm 463 
			String cle = it.next();
1292 cyprien 464 
			//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
974 gduche 465 
			if (!cle.startsWith("gxt.")&&!cle.matches("^_.+_$"))	{
1173 jpm 466 
 
467 
				//Si, et seulement si, la valeur diffère de la valeur initiale OU la clé est dans les champs obligatoire
1292 cyprien 468 
				if (Arrays.asList(getChampsObligatoires()).contains(getPrefixe() + "_" + cle) || ((valeursInitiales.get(cle) != null && !valeursInitiales.get(cle).equals(get(cle))) || valeursInitiales.get(cle) == null))	{
1569 jpm 469 
					post += getPrefixe() + "_" +  cle + "=" + URL.encodeQueryString(renvoyerValeurCorrecte(cle));
1173 jpm 470 
					if (it.hasNext())	{
471 
						post += "&";
472 
					}
826 gduche 473 
				}
385 gduche 474 
			}
475 
		}
1292 cyprien 476 
 
748 jpm 477 
		return post;
786 jpm 478 
	}
479 
 
480 
	/**
481 
	 * Met à jour l'objet this avec les données de l'objet passé en paramêtre.
1569 jpm 482 
	 */
786 jpm 483 
	public void mettreAJour(aDonnee nouveau) {
484 
		Collection<String> cles = nouveau.getProperties().keySet();
485 
		Iterator<String> it = cles.iterator();
486 
		while (it.hasNext())	{
487 
			String cle = it.next();
488 
			if (!this.get(cle).equals(nouveau.get(cle))) {
489 
				this.set(cle, nouveau.get(cle));
490 
			}
491 
		}
492 
	}
69 jpm 493 
}