Subversion Repositories eFlore/Applications.coel

Rev

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