Subversion Repositories eFlore/Applications.coel

Rev

Go to most recent revision | Details | 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;
1173 jpm 9
import java.util.List;
306 jp_milcent 10
import java.util.Map;
193 jp_milcent 11
import java.util.Set;
306 jp_milcent 12
import java.util.TreeSet;
69 jpm 13
 
949 jpm 14
import org.tela_botanica.client.util.Debug;
233 jp_milcent 15
import org.tela_botanica.client.util.UtilArray;
1369 cyprien 16
import org.tela_botanica.client.util.UtilString;
233 jp_milcent 17
 
534 gduche 18
import com.extjs.gxt.ui.client.core.FastMap;
69 jpm 19
import com.extjs.gxt.ui.client.data.BaseModelData;
602 jp_milcent 20
import com.google.gwt.core.client.GWT;
385 gduche 21
import com.google.gwt.http.client.URL;
775 jpm 22
import com.google.gwt.json.client.JSONObject;
69 jpm 23
 
193 jp_milcent 24
/**
25
 * @author jpm
26
 *
27
 */
69 jpm 28
public abstract class aDonnee extends BaseModelData implements Serializable {
29
 
30
	private static final long serialVersionUID = 3527760464061629791L;
748 jpm 31
 
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 = "";
1561 jpm 103
		cle = (removePrefix) ? cle : getPrefixe()+"_"+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) {
124
		cle = (removePrefix) ? cle : getPrefixe()+"_"+cle;
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) {
1569 jpm 202
		champ = (removePrefix) ? champ : getPrefixe()+"_"+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
 
245 jp_milcent 214
	/**
215
	 * Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").
216
	 *
217
	 * @param champ le nom du champ dénormalisé
218
	 */
219
	protected String getChaineDenormaliseUnique(String champ) {
793 jpm 220
		String valeur = renvoyerValeurCorrecte(champ);
245 jp_milcent 221
 
1369 cyprien 222
		if (!UtilString.isEmpty(valeur)) {
793 jpm 223
			valeur = valeur.replaceFirst("^"+TYPE_AUTRE+SEPARATEUR_TYPE_VALEUR, "");
245 jp_milcent 224
		}
225
 
793 jpm 226
		return valeur;
245 jp_milcent 227
	}
228
 
208 jp_milcent 229
	protected String getInfoDenormaliseParType(String chaineExistante, String type) {
230
		String sortie = "";
1369 cyprien 231
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 232
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
208 jp_milcent 233
			for (int i = 0; i < valeurs.length; i++) {
789 jpm 234
				if (valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
235
					sortie =  valeurs[i].replaceFirst("^"+type+SEPARATEUR_TYPE_VALEUR, "");
208 jp_milcent 236
				}
237
			}
238
		}
239
		return sortie;
240
	}
241
 
233 jp_milcent 242
	/**
248 gduche 243
	 * Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur
244
	 *
245
	 * @param champ le nom du champ dénormalisé
246
	 * @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)
247
	 */
248
	public Object getChaineDenormaliseAsMapOrList(String champ)	{
249
 
250
			Object retourObjet = null;
251
 
252
			String valeurChamp = renvoyerValeurCorrecte(champ);
252 gduche 253
 
254
			if ((valeurChamp!=null)&&(!valeurChamp.trim().equals("")))	{
789 jpm 255
				String[] valeurs = valeurChamp.split(SEPARATEUR_VALEURS);
252 gduche 256
 
257
				if (valeurs.length > 0)	{
789 jpm 258
					if (valeurs[0].contains(SEPARATEUR_TYPE_VALEUR))	{
252 gduche 259
						// Les champs sont typés, on en fait une Map
748 jpm 260
						HashMap<String,String> mapValeurs = new HashMap<String,String>();
252 gduche 261
						for (int i = 0; i < valeurs.length; i++)	{
789 jpm 262
							String typeEtValeur[] = valeurs[i].split(SEPARATEUR_TYPE_VALEUR);
263
							mapValeurs.put(typeEtValeur[1], typeEtValeur[0]);
252 gduche 264
						}
265
						retourObjet = mapValeurs;
248 gduche 266
					}
252 gduche 267
					else	{
268
 
269
						//Les champs ne sont pas typés, on en fait une Liste
748 jpm 270
						LinkedList<String> listeValeurs = new LinkedList<String>();
252 gduche 271
						for (int i = 0; i < valeurs.length; i++)	{
272
							if ((valeurs[i]!=null)&&(!valeurs[i].equals("")))	{
273
								listeValeurs.add(valeurs[i]);
274
							}
249 gduche 275
						}
252 gduche 276
						retourObjet = listeValeurs;
248 gduche 277
					}
252 gduche 278
 
248 gduche 279
				}
280
			}
281
 
282
			return retourObjet;
283
 
284
	}
285
 
286
	/**
233 jp_milcent 287
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
288
	 * Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.
602 jp_milcent 289
	 * Si aucun type n'est trouvé, nous en ajoutons un avec la nouvelle valeur.
233 jp_milcent 290
	 *
291
	 * @param champ le nom du champ dénormalisé
292
	 * @param type le type de la valeur à modifier
293
	 * @param valeur la valeur pour le type en question
294
	 */
242 jp_milcent 295
	protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {
608 jp_milcent 296
		if (valeur == null || valeur.equals("")) {
602 jp_milcent 297
			supprimerTypeDansChaineDenormalise(champ, type);
298
		} else if (valeur instanceof String) {
233 jp_milcent 299
			String chaineExistante = renvoyerValeurCorrecte(champ);
602 jp_milcent 300
 
1369 cyprien 301
			if (UtilString.isEmpty(chaineExistante)) {
789 jpm 302
				this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur);
233 jp_milcent 303
			} else {
789 jpm 304
				String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
602 jp_milcent 305
				HashMap<String,String> valeursModifiees = new HashMap<String,String>();
233 jp_milcent 306
				for (int i = 0; i < valeurs.length; i++) {
789 jpm 307
					if (valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
308
						valeursModifiees.put(type, type+SEPARATEUR_TYPE_VALEUR+valeur);
309
					} else if (i == (valeurs.length -1) && !valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
310
						valeursModifiees.put(valeurs[i].split(SEPARATEUR_TYPE_VALEUR)[0], valeurs[i]);
311
						valeursModifiees.put(type, type+SEPARATEUR_TYPE_VALEUR+valeur);
602 jp_milcent 312
					} else {
789 jpm 313
						valeursModifiees.put(valeurs[i].split(SEPARATEUR_TYPE_VALEUR)[0], valeurs[i]);
233 jp_milcent 314
					}
315
				}
602 jp_milcent 316
				String[] tableauValeursModifiees = valeursModifiees.values().toArray(new String[valeursModifiees.size()]);
789 jpm 317
				this.set(champ, UtilArray.implode(tableauValeursModifiees, SEPARATEUR_VALEURS));
233 jp_milcent 318
			}
319
		}
320
	}
321
 
208 jp_milcent 322
	protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {
323
		String sortie = "";
1369 cyprien 324
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 325
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
208 jp_milcent 326
			if (valeurs.length >= position) {
327
				for (int i = 0; i < valeurs.length; i++) {
328
					if (i == (position - 1)) {
789 jpm 329
						if (valeurs[i].contains(SEPARATEUR_TYPE_VALEUR)) {
330
							sortie = valeurs[i].replaceFirst("^[^#]+"+SEPARATEUR_VALEURS, "");
208 jp_milcent 331
						} else {
603 jp_milcent 332
							sortie = valeurs[i];
208 jp_milcent 333
						}
334
						break;
335
					}
336
				}
337
			}
338
		}
339
		return sortie;
340
	}
341
 
233 jp_milcent 342
	/**
343
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
344
	 * Remplace par la valeur l'instance dont la position a été indiquée.
242 jp_milcent 345
	 * Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.
346
	 * Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.
233 jp_milcent 347
	 *
348
	 * @param champ le nom du champ dénormalisé
349
	 * @param position le type de la valeur à modifier
350
	 * @param valeur la valeur à remplacer à la position indiquée
351
	 */
242 jp_milcent 352
	protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {
608 jp_milcent 353
		if (valeur == null || valeur.equals("")) {
603 jp_milcent 354
			supprimerChaineDenormaliseParPosition(champ, position);
355
		} else if (valeur instanceof String) {
233 jp_milcent 356
			String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 357
			if (UtilString.isEmpty(chaineExistante)) {
603 jp_milcent 358
				this.set(champ, valeur);
359
			} else {
789 jpm 360
				String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
603 jp_milcent 361
				if (valeurs.length >= position) {
233 jp_milcent 362
					for (int i = 0; i < valeurs.length; i++) {
363
						if (i == (position - 1)) {
364
							valeurs[i] = (String) valeur;
365
							break;
366
						}
367
					}
789 jpm 368
					this.set(champ, UtilArray.implode(valeurs, SEPARATEUR_VALEURS));
233 jp_milcent 369
				}
370
			}
371
		}
372
	}
373
 
603 jp_milcent 374
	protected void supprimerChaineDenormaliseParPosition(String champ, int position) {
375
		String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 376
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 377
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
603 jp_milcent 378
			HashMap<String,String> valeursModifiees = new HashMap<String,String>();
379
			if (valeurs.length >= position) {
380
				for (int i = 0; i < valeurs.length; i++) {
381
					if (i != (position - 1)) {
382
						valeursModifiees.put(""+i, valeurs[i]);
383
					}
384
				}
385
				String[] tableauValeursModifiees = valeursModifiees.values().toArray(new String[valeursModifiees.size()]);
789 jpm 386
				this.set(champ, UtilArray.implode(tableauValeursModifiees, SEPARATEUR_VALEURS));
603 jp_milcent 387
			}
388
		}
389
	}
390
 
193 jp_milcent 391
	/** (non-Javadoc)
392
	 * @see java.lang.Object#toString()
393
	 */
394
	public String toString() {
395
		String sortie = "";
396
 
397
		// Champs du BaseModelData
398
		Set<String> proprietes = this.getProperties().keySet();
306 jp_milcent 399
		TreeSet<String> proprietesTriees = new TreeSet<String>(proprietes);
400
		for (Iterator<String> it = proprietesTriees.iterator(); it.hasNext();) {
193 jp_milcent 401
			String cle = it.next();
306 jp_milcent 402
			if (this.get(cle) != null && !this.get(cle).equals("")) {
949 jpm 403
				sortie += cle+" : "+this.get(cle).toString()+"\n";
202 jp_milcent 404
			}
193 jp_milcent 405
		}
406
 
407
		return sortie;
408
	}
306 jp_milcent 409
 
410
	public Boolean comparer(BaseModelData objetAComparer) {
411
		Boolean retour = true;
412
		Map<String, Object> a = this.getProperties();
413
		Map<String, Object> b = objetAComparer.getProperties();
414
		if (a.size() != b.size()) {
415
			retour = false;
416
		} else {
417
			Set<String> cles = a.keySet();
418
			Iterator<String> it = cles.iterator();
419
			while (it.hasNext()) {
420
				String cle = it.next();
421
				if (a.get(cle) != null && !a.get(cle).equals(b.get(cle))) {
422
					retour = false;
423
					break;
424
				}
425
			}
426
		}
427
		return retour;
428
	}
429
 
430
	public Object cloner(BaseModelData nouvelleInstance) {
431
		Map<String, Object> proprietes = this.getProperties();
432
		Set<String> cles = proprietes.keySet();
433
		for (Iterator<String> it = cles.iterator(); it.hasNext();) {
434
			String cle = it.next();
435
			nouvelleInstance.set(cle, this.get(cle));
436
		}
437
 
438
		return nouvelleInstance;
439
	}
385 gduche 440
 
441
	/**
748 jpm 442
	 * 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 443
	 * */
748 jpm 444
	public String obtenirChainePOST() {
445
		String post = "";
385 gduche 446
 
748 jpm 447
		FastMap<?> proprietees = (FastMap<?>) getProperties();
448
		Collection<String> cles = proprietees.keySet();
449
		Iterator<String> it = cles.iterator();
385 gduche 450
 
451
		while (it.hasNext())	{
748 jpm 452
			String cle = it.next();
1292 cyprien 453
			//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 454
			if (!cle.startsWith("gxt.")&&!cle.matches("^_.+_$"))	{
1173 jpm 455
 
456
				//Si, et seulement si, la valeur diffère de la valeur initiale OU la clé est dans les champs obligatoire
1292 cyprien 457
				if (Arrays.asList(getChampsObligatoires()).contains(getPrefixe() + "_" + cle) || ((valeursInitiales.get(cle) != null && !valeursInitiales.get(cle).equals(get(cle))) || valeursInitiales.get(cle) == null))	{
1569 jpm 458
					post += getPrefixe() + "_" +  cle + "=" + URL.encodeQueryString(renvoyerValeurCorrecte(cle));
1173 jpm 459
					if (it.hasNext())	{
460
						post += "&";
461
					}
826 gduche 462
				}
385 gduche 463
			}
464
		}
1292 cyprien 465
 
748 jpm 466
		return post;
786 jpm 467
	}
468
 
469
	/**
470
	 * Met à jour l'objet this avec les données de l'objet passé en paramêtre.
1569 jpm 471
	 */
786 jpm 472
	public void mettreAJour(aDonnee nouveau) {
473
		Collection<String> cles = nouveau.getProperties().keySet();
474
		Iterator<String> it = cles.iterator();
475
		while (it.hasNext())	{
476
			String cle = it.next();
477
			if (!this.get(cle).equals(nouveau.get(cle))) {
478
				this.set(cle, nouveau.get(cle));
479
			}
480
		}
481
	}
69 jpm 482
}