Subversion Repositories eFlore/Applications.coel

Rev

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