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