Subversion Repositories eFlore/Applications.coel

Rev

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