Subversion Repositories eFlore/Applications.coel

Rev

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