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