Subversion Repositories eFlore/Applications.coel

Rev

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