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