Subversion Repositories eFlore/Applications.coel

Rev

Rev 255 | 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;
306 jp_milcent 4
import java.util.Collections;
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.List;
9
import java.util.Map;
193 jp_milcent 10
import java.util.Set;
306 jp_milcent 11
import java.util.TreeSet;
69 jpm 12
 
233 jp_milcent 13
import org.tela_botanica.client.util.UtilArray;
14
 
69 jpm 15
import com.extjs.gxt.ui.client.data.BaseModelData;
16
 
193 jp_milcent 17
/**
18
 * @author jpm
19
 *
20
 */
69 jpm 21
public abstract class aDonnee extends BaseModelData implements Serializable {
22
 
23
	/**
24
	 * Identifiant pour sérialisé l'objet...
25
	 */
26
	private static final long serialVersionUID = 3527760464061629791L;
27
 
28
	/**
29
	 * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par
30
	 * cette fonction qui retire les charactères nuls qui font planter
31
	 * l'affichage, il ne faut pas utiliser get directement
32
	 *
33
	 * @param cle
34
	 * @return la valeur associée à la clé
35
	 */
193 jp_milcent 36
	protected String renvoyerValeurCorrecte(String cle) {
188 jp_milcent 37
		String sortie = "";
69 jpm 38
		if (this.get(cle) != null) {
39
			String valeur = this.get(cle);
188 jp_milcent 40
			if (! valeur.equals("null")) {
69 jpm 41
				char nullChar = '\u0000';
42
				String sNull = "" + nullChar;
43
				valeur = valeur.replaceAll(sNull, "");
188 jp_milcent 44
				sortie =  valeur;
69 jpm 45
			}
46
		}
188 jp_milcent 47
		return sortie;
69 jpm 48
	}
233 jp_milcent 49
 
193 jp_milcent 50
	/**
242 jp_milcent 51
	 * Ajoute un nouvel élément avec son type à une chaine dénormalisée.
52
	 * Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".
53
	 * Si l'élément existe déjà, il ne sera pas ajouté.
193 jp_milcent 54
	 *
55
	 * @param champ le nom du champ dénormalisé
56
	 * @param type le type de la valeur à ajouter
57
	 * @param valeur la valeur à ajouter
58
	 */
242 jp_milcent 59
	protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {
193 jp_milcent 60
		if (valeur instanceof String) {
61
			String chaineExistante = renvoyerValeurCorrecte(champ);
62
			if (chaineExistante.equals("")) {
63
				this.set(champ, type+"##"+valeur);
64
			} else {
242 jp_milcent 65
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
66
				if (!chaineExistante.matches("(^|;;)"+type+"##"+valeur+"(;;|$)")) {
67
					this.set(champ, chaineExistante+";;"+type+"##"+valeur);
68
				}
193 jp_milcent 69
			}
70
		}
71
	}
119 jpm 72
 
306 jp_milcent 73
	protected void supprimerTypeDansChaineDenormalise(String champ, String type) {
74
		String chaineExistante = renvoyerValeurCorrecte(champ);
75
		if (!chaineExistante.equals("")) {
76
			// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
77
			if (chaineExistante.matches("(^|;;)"+type+"##")) {
78
				chaineExistante = chaineExistante.replaceFirst(type+"##", "");
79
				chaineExistante = chaineExistante.replaceAll(";;;;", ";;");
80
				chaineExistante = chaineExistante.replaceAll("(^;;|;;$)", "");
81
				this.set(champ, chaineExistante);
82
			}
83
		}
84
	}
85
 
86
	protected void remplacerTypeDansChaineDenormalise(String champ, String type, Object valeur) {
87
		if (valeur != null && !valeur.equals("")) {
88
			ajouterChaineDenormaliseAvecType(champ, type, valeur);
89
		} else {
90
			supprimerTypeDansChaineDenormalise(champ, type);
91
		}
92
	}
233 jp_milcent 93
	/**
242 jp_milcent 94
	 * Ajoute un nouvel élément sans type à une chaine dénormalisée.
95
	 * Champ de type "truk" contenant seulement des valeurs séparées par ";;".
96
	 * Si l'élément existe déjà, il ne sera pas ajouté.
97
	 *
98
	 * @param champ le nom du champ dénormalisé
99
	 * @param valeur la valeur à ajouter
100
	 */
101
	protected void ajouterChaineDenormalise(String champ, Object valeur) {
102
		if (valeur instanceof String) {
103
			String chaineExistante = renvoyerValeurCorrecte(champ);
104
			if (chaineExistante.equals("")) {
105
				this.set(champ, valeur);
106
			} else {
107
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
108
				if (!chaineExistante.matches("(^|;;)"+valeur+"(;;|$)")) {
109
					this.set(champ, chaineExistante+";;"+valeur);
110
				}
111
			}
112
		}
113
	}
114
 
115
	/**
233 jp_milcent 116
	 * Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").
117
	 *
118
	 * @param champ le nom du champ dénormalisé
119
	 * @param type le type de la valeur à ajouter
120
	 * @param valeur la valeur à ajouter
121
	 */
122
	protected void setChaineDenormaliseUnique(String champ, String type, Object valeur) {
123
		if (valeur instanceof String) {
124
			this.set(champ, type+"##"+valeur);
125
		}
126
	}
127
 
245 jp_milcent 128
	/**
129
	 * Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").
130
	 *
131
	 * @param champ le nom du champ dénormalisé
132
	 */
133
	protected String getChaineDenormaliseUnique(String champ) {
134
		String sortie = renvoyerValeurCorrecte(champ);
135
 
136
		if (!sortie.equals("")) {
137
			sortie = sortie.replaceFirst("^AUTRE##", "");
138
		}
139
 
140
		return sortie;
141
	}
142
 
208 jp_milcent 143
	protected String getInfoDenormaliseParType(String chaineExistante, String type) {
144
		String sortie = "";
145
		if (!chaineExistante.equals("")) {
146
			String[] valeurs = chaineExistante.split(";;");
147
			for (int i = 0; i < valeurs.length; i++) {
148
				if (valeurs[i].startsWith(type+"##")) {
149
					sortie =  valeurs[i].replaceFirst("^"+type+"##", "");
150
				}
151
			}
152
		}
153
		return sortie;
154
	}
155
 
248 gduche 156
 
233 jp_milcent 157
	/**
248 gduche 158
	 * Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur
159
	 *
160
	 * @param champ le nom du champ dénormalisé
161
	 * @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)
162
	 */
163
 
164
	public Object getChaineDenormaliseAsMapOrList(String champ)	{
165
 
166
			Object retourObjet = null;
167
 
168
			String valeurChamp = renvoyerValeurCorrecte(champ);
252 gduche 169
 
170
			if ((valeurChamp!=null)&&(!valeurChamp.trim().equals("")))	{
171
				String[] valeurs = valeurChamp.split(";;");
172
 
173
				if (valeurs.length > 0)	{
174
					if (valeurs[0].contains("##"))	{
175
						// Les champs sont typés, on en fait une Map
176
						HashMap mapValeurs = new HashMap();
177
 
178
						for (int i = 0; i < valeurs.length; i++)	{
179
							String typeEtValeur[] = valeurs[i].split("##");
180
							mapValeurs.put(typeEtValeur[0], typeEtValeur[1]);
181
						}
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
	}
69 jpm 351
}