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