Subversion Repositories eFlore/Applications.coel

Rev

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