Subversion Repositories eFlore/Applications.coel

Rev

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