Subversion Repositories eFlore/Applications.cel

Rev

Rev 2 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2 Rev 5
1 
package org.tela_botanica.client.modeles;
 1 
package org.tela_botanica.client.modeles;
2 
 
 2 
 
3 
import java.util.HashMap;
 3 
import java.util.HashMap;
4 
import java.util.Iterator;
 4 
import java.util.Iterator;
5 
import java.util.Set;
 5 
import java.util.Set;
6 
 
 6 
 
7 
import com.google.gwt.json.client.JSONObject;
 7 
import com.google.gwt.json.client.JSONObject;
- 
 
 8 
 
8 
/**
 9 
/**
9 
 *
10 
 *
10 
 * Classe representant une image du carnet,
 11 
 * Classe representant une image du carnet, elle ne contient pas d'image à
11 
 * elle ne contient pas d'image à proprement parler mais
 - 
 
12 
 * plutôt les informations associées ainsi que l'url distante.
 12 
 * proprement parler mais plutôt les informations associées ainsi que l'url
13 
 * C'est une table de hachage qui contient des paires propriété/valeur
13 
 * distante. C'est une table de hachage qui contient des paires propriété/valeur
14 
 *
14 
 *
15 
 */
 15 
 */
16 
public class ImageCarnet extends HashMap<String, String> {
 16 
public class ImageCarnet extends HashMap<String, String> {
17
- 
 
18 
 
 17 
 
19 
	/**
 18 
	/**
20 
	 *
19 
	 *
21 
	 */
 20 
	 */
22 
	private static final long serialVersionUID = -6220175386957259859L;
 21 
	private static final long serialVersionUID = -6220175386957259859L;
23 
 
 22 
 
24 
	/**
 23 
	/**
25 
	 * Constructeur avec un objet JSON
 24 
	 * Constructeur avec un objet JSON
- 
 
 25 
	 *
26 
	 * @param image
 26 
	 * @param image
27 
	 */
 27 
	 */
28 
	public ImageCarnet(JSONObject image)
 28 
	public ImageCarnet(JSONObject image) {
29 
	{
- 
 
30 
		// l'objet JSON est une table de hachage
 29 
		// l'objet JSON est une table de hachage
31 
		Set<String> im = image.keySet() ;
 30 
		Set<String> im = image.keySet();
32
31 
 
33 
		// on la parcourt pour chaque clé
 32 
		// on la parcourt pour chaque clé
34 
		for (Iterator<String> iterator = im.iterator(); iterator.hasNext();) {
 33 
		for (Iterator<String> iterator = im.iterator(); iterator.hasNext();) {
35
34 
 
36 
			// si elle est associée à une valeur, on l'ajoute
 35 
			// si elle est associée à une valeur, on l'ajoute
37 
			String key = iterator.next();
 36 
			String key = iterator.next();
38 
			if(image.get(key).isString() != null)
 37 
			if (image.get(key).isString() != null) {
39 
			{
 - 
 
40 
				String valeur = image.get(key).isString().stringValue() ;
 38 
				String valeur = image.get(key).isString().stringValue();
41 
				this.put(key, valeur) ;
 39 
				this.put(key, valeur);
42 
			}
 - 
 
43 
			else
 40 
			} else {
44 
			{
 - 
 
45 
				// sinon on ajoute la clé avec une valeur vide
 41 
				// sinon on ajoute la clé avec une valeur vide
46 
				String valeur = " " ;
 42 
				String valeur = " ";
47 
				this.put(key, valeur) ;
 43 
				this.put(key, valeur);
48 
			}
 44 
			}
49
45 
 
50 
		}
 46 
		}
51 
 
 47 
 
52 
	}
 48 
	}
53
49 
 
54 
	/**
 50 
	/**
55 
	 * Surcharge de toString qui affiche toutes les propriétés de l'image
 51 
	 * Surcharge de toString qui affiche toutes les propriétés de l'image
56 
	 */
 52 
	 */
57
53 
 
58 
	public String toString()
 54 
	public String toString() {
59 
	{
 - 
 
60 
		String valeur = " ";
 55 
		String valeur = " ";
61
56 
 
62 
		for (Iterator<String> iterator = this.keySet().iterator(); iterator.hasNext();) {
 57 
		for (Iterator<String> iterator = this.keySet().iterator(); iterator
63
- 
 
- 
 
 58 
				.hasNext();) {
64
59 
 
65 
			String key = iterator.next();
 60 
			String key = iterator.next();
66 
			if(this.get(key) != null)
 61 
			if (this.get(key) != null) {
67 
			{
 - 
 
68 
				valeur += "cle : "+key+" valeur :"+this.get(key)+"\n" ;
 62 
				valeur += "cle : " + key + " valeur :" + this.get(key) + "\n";
69 
			}
 63 
			}
70
64 
 
71 
		}
 65 
		}
72
66 
 
73 
		return valeur ;
 67 
		return valeur;
74 
	}
 68 
	}
75
69 
 
76 
	/**
 70 
	/**
77 
	 * Pour éviter que l'on traite des valeurs nulles à l'affichage
 71 
	 * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par
78 
	 * on passe par cette fonction qui retire les charactères nuls qui font planter
 72 
	 * cette fonction qui retire les charactères nuls qui font planter
79 
	 * l'affichage, il ne faut pas utiliser get directement
73 
	 * l'affichage, il ne faut pas utiliser get directement
- 
 
 74 
	 *
80 
	 * @param cle
 75 
	 * @param cle
81 
	 * @return la valeur associée à la clé
 76 
	 * @return la valeur associée à la clé
82 
	 */
 77 
	 */
83 
	public String renvoyerValeurCorrecte(String cle)
 78 
	public String renvoyerValeurCorrecte(String cle) {
84 
	{
 - 
 
85 
		if(this.containsKey((cle)))
 79 
		if (this.containsKey((cle))) {
86 
		{
 - 
 
87 
			String valeur = this.get(cle) ;
 80 
			String valeur = this.get(cle);
88 
			if(valeur.equals("null") || valeur == null)
 81 
			if (valeur.equals("null") || valeur == null) {
89 
			{
 - 
 
90 
				return " " ;
 82 
				return " ";
91 
			}
- 
 
92 
			else
 83 
			} else {
93 
			{
 - 
 
94 
				char nullChar = '\u0000' ;
 84 
				char nullChar = '\u0000';
95 
				String sNull = ""+nullChar ;
85 
				String sNull = "" + nullChar;
96 
				valeur = valeur.replaceAll(sNull, "") ;
 86 
				valeur = valeur.replaceAll(sNull, "");
97 
				return valeur ;
 87 
				return valeur;
98 
			}
 88 
			}
99 
		}
 - 
 
100 
		else
 89 
		} else {
101 
		{
 - 
 
102 
			return " " ;
 90 
			return " ";
103 
		}
 91 
		}
104 
	}
 92 
	}
105 
 
 93 
 
106 
	/**
 94 
	/**
107 
	 * Acesseur pour l'id de l'image
 95 
	 * Acesseur pour l'id de l'image
- 
 
 96 
	 *
108 
	 * @return l'id de l'image
 97 
	 * @return l'id de l'image
109 
	 */
 98 
	 */
110 
	public String getId() {
 99 
	public String getId() {
111
100 
 
112 
		return renvoyerValeurCorrecte("ci_id_image") ;
 101 
		return renvoyerValeurCorrecte("ci_id_image");
113 
	}
 102 
	}
114
103 
 
115 
	/**
 104 
	/**
116 
	 * Acesseur pour le numero d'ordre de l'image
 105 
	 * Acesseur pour le numero d'ordre de l'image
- 
 
 106 
	 *
117 
	 * @return l'ordre de l'image
 107 
	 * @return l'ordre de l'image
118 
	 */
 108 
	 */
119 
	public String getOrdre() {
 109 
	public String getOrdre() {
120
110 
 
121 
		return renvoyerValeurCorrecte("ci_ordre") ;
 111 
		return renvoyerValeurCorrecte("ci_ordre");
122 
	}
 112 
	}
123
113 
 
124 
	/**
 114 
	/**
125 
	 * Base de l'url serveur pour les images
 115 
	 * Base de l'url serveur pour les images
- 
 
 116 
	 *
126 
	 * @return url racine pour les images
 117 
	 * @return url racine pour les images
127 
	 */
 118 
	 */
128 
	public String getBaseUrl()
 119 
	public String getBaseUrl() {
129 
	{
 - 
 
130 
		return "http://162.38.234.9/Documents/images_serveur/" ;
 120 
		return "http://162.38.234.9/Documents/images_serveur/";
131 
	}
 121 
	}
132
122 
 
133 
	/**
 123 
	/**
134 
	 * Renvoie le nom de base du fichier image et ses sous dossier
 124 
	 * Renvoie le nom de base du fichier image et ses sous dossier
- 
 
 125 
	 *
135 
	 * @return le nom de base du fichier de type (XXX_XXX_XXX), et ses sous dossier
 126 
	 * @return le nom de base du fichier de type (XXX_XXX_XXX), et ses sous
- 
 
 127 
	 *         dossier
136 
	 */
 128 
	 */
137 
	public String[] getBaseFileName()
 129 
	public String[] getBaseFileName() {
138 
	{
 - 
 
139 
		String id = getId() ;
 130 
		String id = getId();
140
131 
 
141 
		int maxZeros = 9 - id.length() ;
 132 
		int maxZeros = 9 - id.length();
142
133 
 
143 
		for(int i = 0 ; i < maxZeros ; i++)
 134 
		for (int i = 0; i < maxZeros; i++) {
144 
		{
 - 
 
145 
			id = "0"+id ;
 135 
			id = "0" + id;
146 
		}
 136 
		}
147
137 
 
148 
		String dossierNv1 = id.substring(0, 3) ;
 138 
		String dossierNv1 = id.substring(0, 3);
149 
		String dossierNv2 = id.substring(3, 6) ;
 139 
		String dossierNv2 = id.substring(3, 6);
150 
		String fichierNv = id.substring(6, 9) ;
 140 
		String fichierNv = id.substring(6, 9);
151
141 
 
152 
		String nomFichier = dossierNv1+"_"+dossierNv2+"_"+fichierNv ;
 142 
		String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv;
153
143 
 
154 
		String[] infosFichier = {nomFichier , dossierNv1 , dossierNv2} ;
 144 
		String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 };
155
145 
 
156 
		return infosFichier ;
 146 
		return infosFichier;
157 
	}
 147 
	}
158 
 
 148 
 
159 
	/**
 149 
	/**
160 
	 * Renvoie le chemin et nom du fichier grand format
 150 
	 * Renvoie le chemin et nom du fichier grand format
- 
 
 151 
	 *
161 
	 * @return le chemin du fichier grand format
 152 
	 * @return le chemin du fichier grand format
162 
	 */
 153 
	 */
163 
	public String getLUrl() {
 154 
	public String getLUrl() {
164
155 
 
165 
		String[] infosFichier = getBaseFileName() ;
 156 
		String[] infosFichier = getBaseFileName();
166
157 
 
167 
		return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/L/"+infosFichier[0]+"_L.jpg" ;
 158 
		return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/L/"
- 
 
 159 
				+ infosFichier[0] + "_L.jpg";
168 
	}
 160 
	}
169
161 
 
170 
	/**
 162 
	/**
171 
	 * Renvoie le chemin et nom du fichier petit format
 163 
	 * Renvoie le chemin et nom du fichier petit format
- 
 
 164 
	 *
172 
	 * @return le chemin du fichier petit format
 165 
	 * @return le chemin du fichier petit format
173 
	 */
 166 
	 */
174 
	public String getSUrl() {
 167 
	public String getSUrl() {
175
168 
 
176 
		String[] infosFichier = getBaseFileName() ;
 169 
		String[] infosFichier = getBaseFileName();
177
170 
 
178 
		return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/S/"+infosFichier[0]+"_S.jpg" ;
 171 
		return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/S/"
- 
 
 172 
				+ infosFichier[0] + "_S.jpg";
179 
	}
 173 
	}
180
174 
 
181 
	/**
 175 
	/**
182 
	 * Renvoie le chemin et nom du fichier moyen format
 176 
	 * Renvoie le chemin et nom du fichier moyen format
- 
 
 177 
	 *
183 
	 * @return le chemin du fichier moyen format
 178 
	 * @return le chemin du fichier moyen format
184 
	 */
 179 
	 */
185 
	public String getMUrl() {
 180 
	public String getMUrl() {
186
181 
 
187 
		String[] infosFichier = getBaseFileName() ;
 182 
		String[] infosFichier = getBaseFileName();
188
183 
 
189 
		return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/M/"+infosFichier[0]+"_M.jpg" ;
 184 
		return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/M/"
- 
 
 185 
				+ infosFichier[0] + "_M.jpg";
190 
	}
 186 
	}
191
187 
 
192 
	/**
 188 
	/**
193 
	 * Renvoie la taille de l'image
 189 
	 * Renvoie la taille de l'image
- 
 
 190 
	 *
194 
	 * @return un tableau de deux string contenant la hauteur puis la largeur
191 
	 * @return un tableau de deux string contenant la hauteur puis la largeur
195 
	 */
 192 
	 */
196 
	public String[] getTailleImage()
 193 
	public String[] getTailleImage() {
197 
	{
 - 
 
198 
		String[] XY = { renvoyerValeurCorrecte("ci_meta_height") , renvoyerValeurCorrecte("ci_meta_width") } ;
 194 
		String[] XY = { renvoyerValeurCorrecte("ci_meta_height"),
- 
 
 195 
				renvoyerValeurCorrecte("ci_meta_width") };
199 
		return XY ;
 196 
		return XY;
200 
	}
 197 
	}
201
198 
 
202 
	public String[] getNote()
 199 
	public String[] getNote() {
203 
	{
 - 
 
204 
		String[] note = {renvoyerValeurCorrecte("ci_note_image") } ;
 200 
		String[] note = { renvoyerValeurCorrecte("ci_note_image") };
205 
		return note ;
 201 
		return note;
206 
	}
 202 
	}
207
203 
 
208 
	/**
204 
	/**
209 
	 * Renvoie la date exif associée à l'image
 205 
	 * Renvoie la date exif associée à l'image
- 
 
 206 
	 *
210 
	 * @return la date associée à l'image
 207 
	 * @return la date associée à l'image
211 
	 */
 208 
	 */
212 
	public String getDate() {
 209 
	public String getDate() {
213
210 
 
214 
		return renvoyerValeurCorrecte("ci_meta_date") ;
 211 
		return renvoyerValeurCorrecte("ci_meta_date");
215 
	}
 212 
	}
216 
 
 213 
 
217 
	/**
 214 
	/**
218 
	 * Renvoie la ville associée à l'image
 215 
	 * Renvoie la ville associée à l'image
- 
 
 216 
	 *
219 
	 * @return la ville iptc
 217 
	 * @return la ville iptc
220 
	 */
 218 
	 */
221 
	public Object getIptcCity() {
 219 
	public Object getIptcCity() {
222
220 
 
223 
		return renvoyerValeurCorrecte("ci_meta_iptc_city") ;
 221 
		return renvoyerValeurCorrecte("ci_meta_iptc_city");
224 
	}
 222 
	}
225 
 
 223 
 
226 
	/**
 224 
	/**
227 
	 * Renvoie le fabricant de l'appareil
 225 
	 * Renvoie le fabricant de l'appareil
- 
 
 226 
	 *
228 
	 * @return le fabricant
 227 
	 * @return le fabricant
229 
	 */
 228 
	 */
230 
	public String getMake() {
 229 
	public String getMake() {
231
230 
 
232 
		return renvoyerValeurCorrecte("ci_meta_make") ;
 231 
		return renvoyerValeurCorrecte("ci_meta_make");
233 
	}
 232 
	}
234 
 
 233 
 
235 
	/**
 234 
	/**
236 
	 * Renvoie le modele de l'appareil
 235 
	 * Renvoie le modele de l'appareil
- 
 
 236 
	 *
237 
	 * @return le modele
 237 
	 * @return le modele
238 
	 */
 238 
	 */
239 
	public String getModel() {
 239 
	public String getModel() {
240
240 
 
241 
		return renvoyerValeurCorrecte("ci_meta_model") ;
 241 
		return renvoyerValeurCorrecte("ci_meta_model");
242 
	}
 242 
	}
243
243 
 
244 
	/**
 244 
	/**
245 
	 * Renvoie un tableau nom / valeur de toutes les metadonnées Iptc
 245 
	 * Renvoie un tableau nom / valeur de toutes les metadonnées Iptc
- 
 
 246 
	 *
246 
	 * @return les métadonnées iptc
 247 
	 * @return les métadonnées iptc
247 
	 */
 248 
	 */
248 
	public String[][] getMetadonnesIptc() {
 249 
	public String[][] getMetadonnesIptc() {
249
250 
 
250 
		String[][] metaIptc = new String[14][2] ;
 251 
		String[][] metaIptc = new String[14][2];
251 
		int elem = 0 ;
 252 
		int elem = 0;
252
253 
 
253 
		for (Iterator<String> it = this.keySet().iterator(); it.hasNext();)
254 
		for (Iterator<String> it = this.keySet().iterator(); it.hasNext();) {
254 
		{
 - 
 
255
255 
 
256 
			String key = it.next();
 256 
			String key = it.next();
257
257 
 
258 
				// on filtre le "ci"
 258 
			// on filtre le "ci"
259 
				String type[] = key.split("_",3) ;
 259 
			String type[] = key.split("_", 3);
260
- 
 
261
260 
 
262 
				// si c'est une metadonnee exif ou iptc
 261 
			// si c'est une metadonnee exif ou iptc
263 
				if(type[1].equals("meta"))
 262 
			if (type[1].equals("meta")) {
264 
				{
 - 
 
265 
					String[] genre =  type[2].split("_",2) ;
 263 
				String[] genre = type[2].split("_", 2);
266 
					if(genre[0].equals("iptc"))
 264 
				if (genre[0].equals("iptc")) {
267 
					{
 - 
 
268 
						String nom = genre[1] ;
 265 
					String nom = genre[1];
269 
						metaIptc[elem][0] = nom ;
 266 
					metaIptc[elem][0] = nom;
270 
						metaIptc[elem][1] = renvoyerValeurCorrecte(key) ;
 267 
					metaIptc[elem][1] = renvoyerValeurCorrecte(key);
271 
						elem++ ;
268 
					elem++;
272 
					}
 269 
				}
273
270 
 
274 
				}
271 
			}
275
272 
 
276 
		}
 273 
		}
277
274 
 
278 
		return metaIptc ;
 275 
		return metaIptc;
279 
	}
 276 
	}
280
277 
 
281 
	/**
 278 
	/**
282 
	 * Renvoie un tableau nom / valeur de toutes les metadonnées Exif
 279 
	 * Renvoie un tableau nom / valeur de toutes les metadonnées Exif
- 
 
 280 
	 *
283 
	 * @return les métadonnées Exif
 281 
	 * @return les métadonnées Exif
284 
	 */
 282 
	 */
285 
	public String[][] getMetadonnesExif() {
 283 
	public String[][] getMetadonnesExif() {
286
284 
 
287 
		String[][] metaExif = new String[31][2] ;
 285 
		String[][] metaExif = new String[31][2];
288 
		int elem = 0 ;
 286 
		int elem = 0;
289
287 
 
290 
		for (Iterator<String> it = this.keySet().iterator(); it.hasNext();)
288 
		for (Iterator<String> it = this.keySet().iterator(); it.hasNext();) {
291 
		{
 - 
 
292
289 
 
293 
			String key = it.next();
 290 
			String key = it.next();
294
291 
 
295 
				// on filtre le "ci"
 292 
			// on filtre le "ci"
296 
				String type[] = key.split("_",3) ;
 293 
			String type[] = key.split("_", 3);
297
- 
 
298
294 
 
299 
				// si c'est une metadonnee exif ou iptc
 295 
			// si c'est une metadonnee exif ou iptc
300 
				if(type[1].equals("meta"))
 296 
			if (type[1].equals("meta")) {
301 
				{
 - 
 
302 
					String[] genre =  type[2].split("_",2) ;
 297 
				String[] genre = type[2].split("_", 2);
303 
					if(genre[0].equals("exif"))
 298 
				if (genre[0].equals("exif")) {
304 
					{
 - 
 
305 
						String nom = genre[1] ;
 299 
					String nom = genre[1];
306 
						metaExif[elem][0] = nom ;
 300 
					metaExif[elem][0] = nom;
307 
						metaExif[elem][1] = renvoyerValeurCorrecte(key) ;
 301 
					metaExif[elem][1] = renvoyerValeurCorrecte(key);
308 
						elem++ ;
302 
					elem++;
309 
					}
 303 
				}
310
304 
 
311 
				}
305 
			}
312
306 
 
313 
		}
 307 
		}
314
308 
 
315 
		return metaExif ;
 309 
		return metaExif;
316
310 
 
317 
	}
 311 
	}
318
312 
 
319 
	/**
 313 
	/**
320 
	 * Renvoie un tableau nom / valeur contenant les infos générales
 314 
	 * Renvoie un tableau nom / valeur contenant les infos générales
- 
 
 315 
	 *
321 
	 * @return les infos générales
 316 
	 * @return les infos générales
322 
	 */
 317 
	 */
323 
	public String[][] getInfoGenerales() {
 318 
	public String[][] getInfoGenerales() {
324
319 
 
325 
		String[][] metaGen = new String[2][2] ;
 320 
		String[][] metaGen = new String[2][2];
326
321 
 
327 
		metaGen[0][0] = "ci_meta_comment" ;
 322 
		metaGen[0][0] = "ci_meta_comment";
328 
		metaGen[0][1] = this.renvoyerValeurCorrecte("ci_meta_comment") ;
 323 
		metaGen[0][1] = this.renvoyerValeurCorrecte("ci_meta_comment");
329
324 
 
330 
		metaGen[1][0] = "ci_meta_date" ;
 325 
		metaGen[1][0] = "ci_meta_date";
331 
		metaGen[1][1] = this.renvoyerValeurCorrecte("ci_meta_date") ;
 326 
		metaGen[1][1] = this.renvoyerValeurCorrecte("ci_meta_date");
332
327 
 
333 
		return metaGen ;
 328 
		return metaGen;
334 
	}
 329 
	}
335
330 
 
336 
	/**
 331 
	/**
337 
	 * Renvoie une string contenant les mots clés séparés par des ','
 332 
	 * Renvoie une string contenant les mots clés séparés par des ','
- 
 
 333 
	 *
338 
	 * @return les mots clés
 334 
	 * @return les mots clés
339 
	 */
 335 
	 */
340 
	public String getMotsCles() {
 336 
	public String getMotsCles() {
341
337 
 
342 
		return renvoyerValeurCorrecte("ci_meta_mots_cles") ;
 338 
		return renvoyerValeurCorrecte("ci_meta_mots_cles");
343 
	}
 339 
	}
344
340 
 
345 
	/**
 341 
	/**
346 
	 * Met à jour le commenentaire et la date
 342 
	 * Met à jour le commenentaire et la date
- 
 
 343 
	 *
- 
 
 344 
	 * @param commentaires
347 
	 * @param commentaires le nouveau commentaire
 345 
	 *            le nouveau commentaire
- 
 
 346 
	 * @param date
348 
	 * @param date la nouvelle date
 347 
	 *            la nouvelle date
349 
	 */
 348 
	 */
350 
	public void miseAJourInfoGenerales(String commentaires, String date, String note)
 349 
	public void miseAJourInfoGenerales(String commentaires, String date,
351 
	{
 350 
			String note) {
352 
			put("ci_meta_comment",commentaires) ;
 351 
		put("ci_meta_comment", commentaires);
353 
			put("ci_note_image",note) ;
 352 
		put("ci_note_image", note);
354 
			put("ci_meta_date",date) ;
 353 
		put("ci_meta_date", date);
355 
	}
 354 
	}
356
355 
 
357 
	/**
 356 
	/**
358 
	 * Met à jour les mots clés
 357 
	 * Met à jour les mots clés
- 
 
 358 
	 *
- 
 
 359 
	 * @param motsClesEnCours
359 
	 * @param motsClesEnCours la liste de mots clés séparés par des ','
 360 
	 *            la liste de mots clés séparés par des ','
360 
	 */
 361 
	 */
361 
	public void mettreAjourMotsCles(String motsClesEnCours) {
 362 
	public void mettreAjourMotsCles(String motsClesEnCours) {
362
363 
 
363 
		put("ci_meta_mots_cles",motsClesEnCours) ;
 364 
		put("ci_meta_mots_cles", motsClesEnCours);
364
365 
 
365 
	}
 366 
	}
366
367 
 
367 
}
 368 
}