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