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