WebSVN – eFlore/Applications.coel – Diff – /branches/v1.9-nebbiolo/src/org/tela_botanica/client/modeles/aDonnee.java


package org.tela_botanica.client.modeles;
 
import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
 
import java.util.Set;
 
import org.tela_botanica.client.util.UtilArray;
 
import com.extjs.gxt.ui.client.data.BaseModelData;
 
 
/**
 * @author jpm
 *
 */
public abstract class aDonnee extends BaseModelData implements Serializable {
 
	/**
	 * Identifiant pour sérialisé l'objet...
	 */
	private static final long serialVersionUID = 3527760464061629791L;
 
	/**
	 * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par
	 * cette fonction qui retire les charactères nuls qui font planter
	 * l'affichage, il ne faut pas utiliser get directement
	 * 
	 * @param cle
	 * @return la valeur associée à la clé
	 */
	protected String renvoyerValeurCorrecte(String cle) {
		String sortie = "";
		if (this.get(cle) != null) {
			String valeur = this.get(cle);
			if (! valeur.equals("null")) {
				char nullChar = '\u0000';
				String sNull = "" + nullChar;
				valeur = valeur.replaceAll(sNull, "");
				sortie =  valeur;
			}
		}
		return sortie;
	}
	
	/**
	 * Ajoute un nouvel élément avec son type à une chaine dénormalisée.
	 * Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".
	 * Si l'élément existe déjà, il ne sera pas ajouté.
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param type le type de la valeur à ajouter
	 * @param valeur la valeur à ajouter
	 */
	protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {
		if (valeur instanceof String) {
			String chaineExistante = renvoyerValeurCorrecte(champ);
			if (chaineExistante.equals("")) {
				this.set(champ, type+"##"+valeur);
			} else {
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
				if (!chaineExistante.matches("(^|;;)"+type+"##"+valeur+"(;;|$)")) {
					this.set(champ, chaineExistante+";;"+type+"##"+valeur);
				}
			}
		}
	}
	
	/**
	 * Ajoute un nouvel élément sans type à une chaine dénormalisée.
	 * Champ de type "truk" contenant seulement des valeurs séparées par ";;".
	 * Si l'élément existe déjà, il ne sera pas ajouté.
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param valeur la valeur à ajouter
	 */
	protected void ajouterChaineDenormalise(String champ, Object valeur) {
		if (valeur instanceof String) {
			String chaineExistante = renvoyerValeurCorrecte(champ);
			if (chaineExistante.equals("")) {
				this.set(champ, valeur);
			} else {
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
				if (!chaineExistante.matches("(^|;;)"+valeur+"(;;|$)")) {
					this.set(champ, chaineExistante+";;"+valeur);
				}
			}
		}
	}
	
	/**
	 * Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param type le type de la valeur à ajouter
	 * @param valeur la valeur à ajouter
	 */
	protected void setChaineDenormaliseUnique(String champ, String type, Object valeur) {
		if (valeur instanceof String) {
			this.set(champ, type+"##"+valeur);
		}
	}
	
	/**
	 * Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").
	 * 
	 * @param champ le nom du champ dénormalisé
	 */
	protected String getChaineDenormaliseUnique(String champ) {
		String sortie = renvoyerValeurCorrecte(champ);
		
		if (!sortie.equals("")) {
			sortie = sortie.replaceFirst("^AUTRE##", "");
		}
		
		return sortie;
	}
	
	protected String getInfoDenormaliseParType(String chaineExistante, String type) {
		String sortie = "";
		if (!chaineExistante.equals("")) {
			String[] valeurs = chaineExistante.split(";;");
			for (int i = 0; i < valeurs.length; i++) {
				if (valeurs[i].startsWith(type+"##")) {
					sortie =  valeurs[i].replaceFirst("^"+type+"##", "");
				}
			}
		}
		return sortie;
	}
	
	
	/**
	 * Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)
	 */
	
	public Object getChaineDenormaliseAsMapOrList(String champ)	{
				
			Object retourObjet = null;
			
			String valeurChamp = renvoyerValeurCorrecte(champ);
			
			if ((valeurChamp!=null)&&(!valeurChamp.trim().equals("")))	{
				String[] valeurs = valeurChamp.split(";;");
			
				if (valeurs.length > 0)	{
					if (valeurs[0].contains("##"))	{
						// Les champs sont typés, on en fait une Map
						HashMap mapValeurs = new HashMap();
						
						for (int i = 0; i < valeurs.length; i++)	{
							String typeEtValeur[] = valeurs[i].split("##");
							mapValeurs.put(typeEtValeur[0], typeEtValeur[1]);						
						}
						
						retourObjet = mapValeurs;
					}
					else	{
						
						//Les champs ne sont pas typés, on en fait une Liste
						LinkedList listeValeurs = new LinkedList<String>();
						for (int i = 0; i < valeurs.length; i++)	{
							if ((valeurs[i]!=null)&&(!valeurs[i].equals("")))	{
								listeValeurs.add(valeurs[i]);
							}
						}
						retourObjet = listeValeurs;
					}
					
				}
			}
			
			return retourObjet;
			
	}
	
	
	/**
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
	 * Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param type le type de la valeur à modifier
	 * @param valeur la valeur pour le type en question
	 */
	protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {
		if (valeur instanceof String) {
			String chaineExistante = renvoyerValeurCorrecte(champ);
			if (chaineExistante.equals("")) {
				this.set(champ, type+"##"+valeur);
			} else {
				String[] valeurs = chaineExistante.split(";;");
				for (int i = 0; i < valeurs.length; i++) {
					if (valeurs[i].startsWith(type+"##") || i == (valeurs.length -1)) {
						valeurs[i] = type+"##"+valeur;
						break;
					}
				}
				this.set(champ, UtilArray.implode(valeurs, ";;"));
			}
		}
	}
	
	protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {
		String sortie = "";
		if (!chaineExistante.equals("")) {
			String[] valeurs = chaineExistante.split(";;");
			if (valeurs.length >= position) {
				for (int i = 0; i < valeurs.length; i++) {
					if (i == (position - 1)) {
						if (valeurs[i].contains("##")) {
							sortie =  valeurs[i].replaceFirst("^[^#]+##", "");
						} else {
							sortie =  valeurs[i];
						}
						break;
					}
				}
			}
		}
		return sortie;
	}
	
	/**
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
	 * Remplace par la valeur l'instance dont la position a été indiquée.
	 * Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.
	 * Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param position le type de la valeur à modifier
	 * @param valeur la valeur à remplacer à la position indiquée
	 */
	protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {
		if (valeur instanceof String) {
			String chaineExistante = renvoyerValeurCorrecte(champ);
			if (!chaineExistante.equals("")) {
				String[] valeurs = chaineExistante.split(";;");
				if (valeurs.length == 0) {
					this.set(champ, valeur);
				} else if (valeurs.length >= position) {
					for (int i = 0; i < valeurs.length; i++) {
						if (i == (position - 1)) {
							valeurs[i] = (String) valeur;
							break;
						}
					}
					this.set(champ, UtilArray.implode(valeurs, ";;"));
				}
			}
		}
	}
	
	public String getDateModification() {
		return (String) renvoyerValeurCorrecte("cmhl_date_modification");
	}
	
	public String getNotes() {
		return (String) renvoyerValeurCorrecte("cmhl_notes");
	}
	
	public String getIdModifierPar() {
		return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");
	}
	
	public String getIdEtat() {
		return (String) renvoyerValeurCorrecte("cmhl_ce_etat");
	}
	
	public String getIp() {
		return (String) renvoyerValeurCorrecte("cmhl_ip");
	}
	
	/** (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		String sortie = "";
		
		// Champs du BaseModelData
		Set<String> proprietes = this.getProperties().keySet();
		for (Iterator<String> it = proprietes.iterator(); it.hasNext();) {
			String cle = it.next();
			if (!this.get(cle).equals("")) {
				sortie += cle+" : "+this.get(cle)+"\n";
			}
		}
		
		return sortie;
	}
}

Subversion Repositories eFlore/Applications.coel

(root)/branches/v1.9-nebbiolo/src/org/tela_botanica/client/modeles/aDonnee.java @ 1901 – Rev 252 → 255

Rev 252		Rev 255
1	`package org.tela_botanica.client.modeles;`	1	`package org.tela_botanica.client.modeles;`
2		2
3	`import java.io.Serializable;`	3	`import java.io.Serializable;`
4	`import java.util.HashMap;`	4	`import java.util.HashMap;`
5	`import java.util.Iterator;`	5	`import java.util.Iterator;`
6	`import java.util.LinkedList;`	6	`import java.util.LinkedList;`
7	`import java.util.List;`	-
8	`import java.util.Set;`	7	`import java.util.Set;`
9		8
10	`import org.tela_botanica.client.util.UtilArray;`	9	`import org.tela_botanica.client.util.UtilArray;`
11		10
12	`import com.extjs.gxt.ui.client.data.BaseModelData;`	11	`import com.extjs.gxt.ui.client.data.BaseModelData;`
13	`import com.extjs.gxt.ui.client.widget.form.CheckBox;`	-
14		12
15	`/**`	13	`/**`
16	`* @author jpm`	14	`* @author jpm`
17	`*`	15	`*`
18	`*/`	16	`*/`
19	`public abstract class aDonnee extends BaseModelData implements Serializable {`	17	`public abstract class aDonnee extends BaseModelData implements Serializable {`
20		18
21	`/**`	19	`/**`
22	`* Identifiant pour sérialisé l'objet...`	20	`* Identifiant pour sérialisé l'objet...`
23	`*/`	21	`*/`
24	`private static final long serialVersionUID = 3527760464061629791L;`	22	`private static final long serialVersionUID = 3527760464061629791L;`
25		23
26	`/**`	24	`/**`
27	`* Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par`	25	`* Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par`
28	`* cette fonction qui retire les charactères nuls qui font planter`	26	`* cette fonction qui retire les charactères nuls qui font planter`
29	`* l'affichage, il ne faut pas utiliser get directement`	27	`* l'affichage, il ne faut pas utiliser get directement`
30	`*`	28	`*`
31	`* @param cle`	29	`* @param cle`
32	`* @return la valeur associée à la clé`	30	`* @return la valeur associée à la clé`
33	`*/`	31	`*/`
34	`protected String renvoyerValeurCorrecte(String cle) {`	32	`protected String renvoyerValeurCorrecte(String cle) {`
35	`String sortie = "";`	33	`String sortie = "";`
36	`if (this.get(cle) != null) {`	34	`if (this.get(cle) != null) {`
37	`String valeur = this.get(cle);`	35	`String valeur = this.get(cle);`
38	`if (! valeur.equals("null")) {`	36	`if (! valeur.equals("null")) {`
39	`char nullChar = '\u0000';`	37	`char nullChar = '\u0000';`
40	`String sNull = "" + nullChar;`	38	`String sNull = "" + nullChar;`
41	`valeur = valeur.replaceAll(sNull, "");`	39	`valeur = valeur.replaceAll(sNull, "");`
42	`sortie = valeur;`	40	`sortie = valeur;`
43	`}`	41	`}`
44	`}`	42	`}`
45	`return sortie;`	43	`return sortie;`
46	`}`	44	`}`
47		45
48	`/**`	46	`/**`
49	`* Ajoute un nouvel élément avec son type à une chaine dénormalisée.`	47	`* Ajoute un nouvel élément avec son type à une chaine dénormalisée.`
50	`* Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".`	48	`* Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".`
51	`* Si l'élément existe déjà, il ne sera pas ajouté.`	49	`* Si l'élément existe déjà, il ne sera pas ajouté.`
52	`*`	50	`*`
53	`* @param champ le nom du champ dénormalisé`	51	`* @param champ le nom du champ dénormalisé`
54	`* @param type le type de la valeur à ajouter`	52	`* @param type le type de la valeur à ajouter`
55	`* @param valeur la valeur à ajouter`	53	`* @param valeur la valeur à ajouter`
56	`*/`	54	`*/`
57	`protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {`	55	`protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {`
58	`if (valeur instanceof String) {`	56	`if (valeur instanceof String) {`
59	`String chaineExistante = renvoyerValeurCorrecte(champ);`	57	`String chaineExistante = renvoyerValeurCorrecte(champ);`
60	`if (chaineExistante.equals("")) {`	58	`if (chaineExistante.equals("")) {`
61	`this.set(champ, type+"##"+valeur);`	59	`this.set(champ, type+"##"+valeur);`
62	`} else {`	60	`} else {`
63	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`	61	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`
64	`if (!chaineExistante.matches("(^\|;;)"+type+"##"+valeur+"(;;\|$)")) {`	62	`if (!chaineExistante.matches("(^\|;;)"+type+"##"+valeur+"(;;\|$)")) {`
65	`this.set(champ, chaineExistante+";;"+type+"##"+valeur);`	63	`this.set(champ, chaineExistante+";;"+type+"##"+valeur);`
66	`}`	64	`}`
67	`}`	65	`}`
68	`}`	66	`}`
69	`}`	67	`}`
70		68
71	`/**`	69	`/**`
72	`* Ajoute un nouvel élément sans type à une chaine dénormalisée.`	70	`* Ajoute un nouvel élément sans type à une chaine dénormalisée.`
73	`* Champ de type "truk" contenant seulement des valeurs séparées par ";;".`	71	`* Champ de type "truk" contenant seulement des valeurs séparées par ";;".`
74	`* Si l'élément existe déjà, il ne sera pas ajouté.`	72	`* Si l'élément existe déjà, il ne sera pas ajouté.`
75	`*`	73	`*`
76	`* @param champ le nom du champ dénormalisé`	74	`* @param champ le nom du champ dénormalisé`
77	`* @param valeur la valeur à ajouter`	75	`* @param valeur la valeur à ajouter`
78	`*/`	76	`*/`
79	`protected void ajouterChaineDenormalise(String champ, Object valeur) {`	77	`protected void ajouterChaineDenormalise(String champ, Object valeur) {`
80	`if (valeur instanceof String) {`	78	`if (valeur instanceof String) {`
81	`String chaineExistante = renvoyerValeurCorrecte(champ);`	79	`String chaineExistante = renvoyerValeurCorrecte(champ);`
82	`if (chaineExistante.equals("")) {`	80	`if (chaineExistante.equals("")) {`
83	`this.set(champ, valeur);`	81	`this.set(champ, valeur);`
84	`} else {`	82	`} else {`
85	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`	83	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`
86	`if (!chaineExistante.matches("(^\|;;)"+valeur+"(;;\|$)")) {`	84	`if (!chaineExistante.matches("(^\|;;)"+valeur+"(;;\|$)")) {`
87	`this.set(champ, chaineExistante+";;"+valeur);`	85	`this.set(champ, chaineExistante+";;"+valeur);`
88	`}`	86	`}`
89	`}`	87	`}`
90	`}`	88	`}`
91	`}`	89	`}`
92		90
93	`/**`	91	`/**`
94	`* Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").`	92	`* Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").`
95	`*`	93	`*`
96	`* @param champ le nom du champ dénormalisé`	94	`* @param champ le nom du champ dénormalisé`
97	`* @param type le type de la valeur à ajouter`	95	`* @param type le type de la valeur à ajouter`
98	`* @param valeur la valeur à ajouter`	96	`* @param valeur la valeur à ajouter`
99	`*/`	97	`*/`
100	`protected void setChaineDenormaliseUnique(String champ, String type, Object valeur) {`	98	`protected void setChaineDenormaliseUnique(String champ, String type, Object valeur) {`
101	`if (valeur instanceof String) {`	99	`if (valeur instanceof String) {`
102	`this.set(champ, type+"##"+valeur);`	100	`this.set(champ, type+"##"+valeur);`
103	`}`	101	`}`
104	`}`	102	`}`
105		103
106	`/**`	104	`/**`
107	`* Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").`	105	`* Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").`
108	`*`	106	`*`
109	`* @param champ le nom du champ dénormalisé`	107	`* @param champ le nom du champ dénormalisé`
110	`*/`	108	`*/`
111	`protected String getChaineDenormaliseUnique(String champ) {`	109	`protected String getChaineDenormaliseUnique(String champ) {`
112	`String sortie = renvoyerValeurCorrecte(champ);`	110	`String sortie = renvoyerValeurCorrecte(champ);`
113		111
114	`if (!sortie.equals("")) {`	112	`if (!sortie.equals("")) {`
115	`sortie = sortie.replaceFirst("^AUTRE##", "");`	113	`sortie = sortie.replaceFirst("^AUTRE##", "");`
116	`}`	114	`}`
117		115
118	`return sortie;`	116	`return sortie;`
119	`}`	117	`}`
120		118
121	`protected String getInfoDenormaliseParType(String chaineExistante, String type) {`	119	`protected String getInfoDenormaliseParType(String chaineExistante, String type) {`
122	`String sortie = "";`	120	`String sortie = "";`
123	`if (!chaineExistante.equals("")) {`	121	`if (!chaineExistante.equals("")) {`
124	`String[] valeurs = chaineExistante.split(";;");`	122	`String[] valeurs = chaineExistante.split(";;");`
125	`for (int i = 0; i < valeurs.length; i++) {`	123	`for (int i = 0; i < valeurs.length; i++) {`
126	`if (valeurs[i].startsWith(type+"##")) {`	124	`if (valeurs[i].startsWith(type+"##")) {`
127	`sortie = valeurs[i].replaceFirst("^"+type+"##", "");`	125	`sortie = valeurs[i].replaceFirst("^"+type+"##", "");`
128	`}`	126	`}`
129	`}`	127	`}`
130	`}`	128	`}`
131	`return sortie;`	129	`return sortie;`
132	`}`	130	`}`
133		131
134		132
135	`/**`	133	`/**`
136	`* Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur`	134	`* Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur`
137	`*`	135	`*`
138	`* @param champ le nom du champ dénormalisé`	136	`* @param champ le nom du champ dénormalisé`
139	`* @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)`	137	`* @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)`
140	`*/`	138	`*/`
141		139
142	`public Object getChaineDenormaliseAsMapOrList(String champ) {`	140	`public Object getChaineDenormaliseAsMapOrList(String champ) {`
143		141
144	`Object retourObjet = null;`	142	`Object retourObjet = null;`
145		143
146	`String valeurChamp = renvoyerValeurCorrecte(champ);`	144	`String valeurChamp = renvoyerValeurCorrecte(champ);`
147		145
148	`if ((valeurChamp!=null)&&(!valeurChamp.trim().equals(""))) {`	146	`if ((valeurChamp!=null)&&(!valeurChamp.trim().equals(""))) {`
149	`String[] valeurs = valeurChamp.split(";;");`	147	`String[] valeurs = valeurChamp.split(";;");`
150		148
151	`if (valeurs.length > 0) {`	149	`if (valeurs.length > 0) {`
152	`if (valeurs[0].contains("##")) {`	150	`if (valeurs[0].contains("##")) {`
153	`// Les champs sont typés, on en fait une Map`	151	`// Les champs sont typés, on en fait une Map`
154	`HashMap mapValeurs = new HashMap();`	152	`HashMap mapValeurs = new HashMap();`
155		153
156	`for (int i = 0; i < valeurs.length; i++) {`	154	`for (int i = 0; i < valeurs.length; i++) {`
157	`String typeEtValeur[] = valeurs[i].split("##");`	155	`String typeEtValeur[] = valeurs[i].split("##");`
158	`mapValeurs.put(typeEtValeur[0], typeEtValeur[1]);`	156	`mapValeurs.put(typeEtValeur[0], typeEtValeur[1]);`
159	`}`	157	`}`
160		158
161	`retourObjet = mapValeurs;`	159	`retourObjet = mapValeurs;`
162	`}`	160	`}`
163	`else {`	161	`else {`
164		162
165	`//Les champs ne sont pas typés, on en fait une Liste`	163	`//Les champs ne sont pas typés, on en fait une Liste`
166	`LinkedList listeValeurs = new LinkedList<String>();`	164	`LinkedList listeValeurs = new LinkedList<String>();`
167	`for (int i = 0; i < valeurs.length; i++) {`	165	`for (int i = 0; i < valeurs.length; i++) {`
168	`if ((valeurs[i]!=null)&&(!valeurs[i].equals(""))) {`	166	`if ((valeurs[i]!=null)&&(!valeurs[i].equals(""))) {`
169	`listeValeurs.add(valeurs[i]);`	167	`listeValeurs.add(valeurs[i]);`
170	`}`	168	`}`
171	`}`	169	`}`
172	`retourObjet = listeValeurs;`	170	`retourObjet = listeValeurs;`
173	`}`	171	`}`
174		172
175	`}`	173	`}`
176	`}`	174	`}`
177		175
178	`return retourObjet;`	176	`return retourObjet;`
179		177
180	`}`	178	`}`
181		179
182		180
183	`/**`	181	`/**`
184	`* Permet de modifier correctement une chaine dénormalisée (champ de type "truk").`	182	`* Permet de modifier correctement une chaine dénormalisée (champ de type "truk").`
185	`* Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.`	183	`* Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.`
186	`*`	184	`*`
187	`* @param champ le nom du champ dénormalisé`	185	`* @param champ le nom du champ dénormalisé`
188	`* @param type le type de la valeur à modifier`	186	`* @param type le type de la valeur à modifier`
189	`* @param valeur la valeur pour le type en question`	187	`* @param valeur la valeur pour le type en question`
190	`*/`	188	`*/`
191	`protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {`	189	`protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {`
192	`if (valeur instanceof String) {`	190	`if (valeur instanceof String) {`
193	`String chaineExistante = renvoyerValeurCorrecte(champ);`	191	`String chaineExistante = renvoyerValeurCorrecte(champ);`
194	`if (chaineExistante.equals("")) {`	192	`if (chaineExistante.equals("")) {`
195	`this.set(champ, type+"##"+valeur);`	193	`this.set(champ, type+"##"+valeur);`
196	`} else {`	194	`} else {`
197	`String[] valeurs = chaineExistante.split(";;");`	195	`String[] valeurs = chaineExistante.split(";;");`
198	`for (int i = 0; i < valeurs.length; i++) {`	196	`for (int i = 0; i < valeurs.length; i++) {`
199	`if (valeurs[i].startsWith(type+"##") \|\| i == (valeurs.length -1)) {`	197	`if (valeurs[i].startsWith(type+"##") \|\| i == (valeurs.length -1)) {`
200	`valeurs[i] = type+"##"+valeur;`	198	`valeurs[i] = type+"##"+valeur;`
201	`break;`	199	`break;`
202	`}`	200	`}`
203	`}`	201	`}`
204	`this.set(champ, UtilArray.implode(valeurs, ";;"));`	202	`this.set(champ, UtilArray.implode(valeurs, ";;"));`
205	`}`	203	`}`
206	`}`	204	`}`
207	`}`	205	`}`
208		206
209	`protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {`	207	`protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {`
210	`String sortie = "";`	208	`String sortie = "";`
211	`if (!chaineExistante.equals("")) {`	209	`if (!chaineExistante.equals("")) {`
212	`String[] valeurs = chaineExistante.split(";;");`	210	`String[] valeurs = chaineExistante.split(";;");`
213	`if (valeurs.length >= position) {`	211	`if (valeurs.length >= position) {`
214	`for (int i = 0; i < valeurs.length; i++) {`	212	`for (int i = 0; i < valeurs.length; i++) {`
215	`if (i == (position - 1)) {`	213	`if (i == (position - 1)) {`
216	`if (valeurs[i].contains("##")) {`	214	`if (valeurs[i].contains("##")) {`
217	`sortie = valeurs[i].replaceFirst("^[^#]+##", "");`	215	`sortie = valeurs[i].replaceFirst("^[^#]+##", "");`
218	`} else {`	216	`} else {`
219	`sortie = valeurs[i];`	217	`sortie = valeurs[i];`
220	`}`	218	`}`
221	`break;`	219	`break;`
222	`}`	220	`}`
223	`}`	221	`}`
224	`}`	222	`}`
225	`}`	223	`}`
226	`return sortie;`	224	`return sortie;`
227	`}`	225	`}`
228		226
229	`/**`	227	`/**`
230	`* Permet de modifier correctement une chaine dénormalisée (champ de type "truk").`	228	`* Permet de modifier correctement une chaine dénormalisée (champ de type "truk").`
231	`* Remplace par la valeur l'instance dont la position a été indiquée.`	229	`* Remplace par la valeur l'instance dont la position a été indiquée.`
232	`* Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.`	230	`* Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.`
233	`* Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.`	231	`* Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.`
234	`*`	232	`*`
235	`* @param champ le nom du champ dénormalisé`	233	`* @param champ le nom du champ dénormalisé`
236	`* @param position le type de la valeur à modifier`	234	`* @param position le type de la valeur à modifier`
237	`* @param valeur la valeur à remplacer à la position indiquée`	235	`* @param valeur la valeur à remplacer à la position indiquée`
238	`*/`	236	`*/`
239	`protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {`	237	`protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {`
240	`if (valeur instanceof String) {`	238	`if (valeur instanceof String) {`
241	`String chaineExistante = renvoyerValeurCorrecte(champ);`	239	`String chaineExistante = renvoyerValeurCorrecte(champ);`
242	`if (!chaineExistante.equals("")) {`	240	`if (!chaineExistante.equals("")) {`
243	`String[] valeurs = chaineExistante.split(";;");`	241	`String[] valeurs = chaineExistante.split(";;");`
244	`if (valeurs.length == 0) {`	242	`if (valeurs.length == 0) {`
245	`this.set(champ, valeur);`	243	`this.set(champ, valeur);`
246	`} else if (valeurs.length >= position) {`	244	`} else if (valeurs.length >= position) {`
247	`for (int i = 0; i < valeurs.length; i++) {`	245	`for (int i = 0; i < valeurs.length; i++) {`
248	`if (i == (position - 1)) {`	246	`if (i == (position - 1)) {`
249	`valeurs[i] = (String) valeur;`	247	`valeurs[i] = (String) valeur;`
250	`break;`	248	`break;`
251	`}`	249	`}`
252	`}`	250	`}`
253	`this.set(champ, UtilArray.implode(valeurs, ";;"));`	251	`this.set(champ, UtilArray.implode(valeurs, ";;"));`
254	`}`	252	`}`
255	`}`	253	`}`
256	`}`	254	`}`
257	`}`	255	`}`
258		256
259	`public String getDateModification() {`	257	`public String getDateModification() {`
260	`return (String) renvoyerValeurCorrecte("cmhl_date_modification");`	258	`return (String) renvoyerValeurCorrecte("cmhl_date_modification");`
261	`}`	259	`}`
262		260
263	`public String getNotes() {`	261	`public String getNotes() {`
264	`return (String) renvoyerValeurCorrecte("cmhl_notes");`	262	`return (String) renvoyerValeurCorrecte("cmhl_notes");`
265	`}`	263	`}`
266		264
267	`public String getIdModifierPar() {`	265	`public String getIdModifierPar() {`
268	`return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");`	266	`return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");`
269	`}`	267	`}`
270		268
271	`public String getIdEtat() {`	269	`public String getIdEtat() {`
272	`return (String) renvoyerValeurCorrecte("cmhl_ce_etat");`	270	`return (String) renvoyerValeurCorrecte("cmhl_ce_etat");`
273	`}`	271	`}`
274		272
275	`public String getIp() {`	273	`public String getIp() {`
276	`return (String) renvoyerValeurCorrecte("cmhl_ip");`	274	`return (String) renvoyerValeurCorrecte("cmhl_ip");`
277	`}`	275	`}`
278		276
279	`/** (non-Javadoc)`	277	`/** (non-Javadoc)`
280	`* @see java.lang.Object#toString()`	278	`* @see java.lang.Object#toString()`
281	`*/`	279	`*/`
282	`public String toString() {`	280	`public String toString() {`
283	`String sortie = "";`	281	`String sortie = "";`
284		282
285	`// Champs du BaseModelData`	283	`// Champs du BaseModelData`
286	`Set<String> proprietes = this.getProperties().keySet();`	284	`Set<String> proprietes = this.getProperties().keySet();`
287	`for (Iterator<String> it = proprietes.iterator(); it.hasNext();) {`	285	`for (Iterator<String> it = proprietes.iterator(); it.hasNext();) {`
288	`String cle = it.next();`	286	`String cle = it.next();`
289	`if (!this.get(cle).equals("")) {`	287	`if (!this.get(cle).equals("")) {`
290	`sortie += cle+" : "+this.get(cle)+"\n";`	288	`sortie += cle+" : "+this.get(cle)+"\n";`
291	`}`	289	`}`
292	`}`	290	`}`
293		291
294	`return sortie;`	292	`return sortie;`
295	`}`	293	`}`
296	`}`	294	`}`