Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 aperonnet 1
package org.tela_botanica.client.image;
2
 
3
import java.util.HashMap;
4
import java.util.Iterator;
5 aperonnet 5
import java.util.Vector;
2 aperonnet 6
 
7
import org.tela_botanica.client.interfaces.Rafraichissable;
989 aurelien 8
import org.tela_botanica.client.modeles.dao.ImageAsynchroneDAO;
9
import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO;
10
import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO;
11
import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;
12
import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO;
13
import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO;
14
import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;
15
import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;
16
import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO;
17
import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;
18
import org.tela_botanica.client.modeles.objets.Configuration;
19
import org.tela_botanica.client.modeles.objets.ImageCarnet;
20
import org.tela_botanica.client.modeles.objets.ListeImageCarnet;
21
import org.tela_botanica.client.modeles.objets.ListeObservation;
22
import org.tela_botanica.client.modeles.objets.Utilisateur;
2 aperonnet 23
 
24
import com.google.gwt.json.client.JSONArray;
25
import com.google.gwt.json.client.JSONObject;
400 aurelien 26
import com.google.gwt.user.client.Window;
2 aperonnet 27
import com.gwtext.client.data.ArrayReader;
28
import com.gwtext.client.data.FieldDef;
29
import com.gwtext.client.data.IntegerFieldDef;
30
import com.gwtext.client.data.MemoryProxy;
31
import com.gwtext.client.data.Node;
32
import com.gwtext.client.data.RecordDef;
33
import com.gwtext.client.data.Store;
34
import com.gwtext.client.data.StringFieldDef;
35
import com.gwtext.client.data.Tree;
36
import com.gwtext.client.widgets.tree.TreeNode;
37
 
38
/**
5 aperonnet 39
 * Modèle d'accès aux données pour les images. C'est un singleton
40
 *
2 aperonnet 41
 * @author aurelien
5 aperonnet 42
 *
2 aperonnet 43
 */
44
public class ImageModele implements Rafraichissable {
5 aperonnet 45
 
2 aperonnet 46
	/**
5 aperonnet 47
	 * Booleen indiquant si le médiateur est instancié (l'instance doit être
48
	 * unique donc le booleen est static)
2 aperonnet 49
	 */
5 aperonnet 50
	private static boolean estInstancie = false;
51
 
2 aperonnet 52
	/**
53
	 * le modèle lui même
54
	 */
5 aperonnet 55
	private static ImageModele thisModele = null;
56
 
2 aperonnet 57
	/**
58
	 * Le médiateur associé au modèle
59
	 */
5 aperonnet 60
	private ImageMediateur iMediateur = null;
61
 
2 aperonnet 62
	/**
63
	 * La configuration en cours
64
	 */
5 aperonnet 65
	private Configuration config = null;
66
 
2 aperonnet 67
	/**
68
	 * La liste des image affichées en cours
69
	 */
5 aperonnet 70
	private ListeImageCarnet cacheImage = new ListeImageCarnet(0);
2 aperonnet 71
	/**
72
	 * Table de correspondance entre les mots clés et leurs identifiants
73
	 */
5 aperonnet 74
	private HashMap<String, String> motsCles = new HashMap<String, String>(0);
2 aperonnet 75
	/**
5 aperonnet 76
	 * Le store contenant les données à afficher, que le modèle transmet au
77
	 * médiateur quand il le demande
2 aperonnet 78
	 */
5 aperonnet 79
	private Store st = null;
2 aperonnet 80
	/**
81
	 * Arbre des mots clés
82
	 */
5 aperonnet 83
	private com.gwtext.client.data.Tree arbreMotsCles = new Tree();
84
 
2 aperonnet 85
	/**
86
	 * Numéro de page en cours
87
	 */
5 aperonnet 88
	private int pageEncours = 0;
2 aperonnet 89
	/**
90
	 * Nombre de pages totales
91
	 */
5 aperonnet 92
	private int pageMax = 1;
2 aperonnet 93
	/**
94
	 * Taille de page (par défaut 50)
95
	 */
5 aperonnet 96
	private int taillePage = 50;
2 aperonnet 97
	/**
98
	 * Nombre d'éléments total correspondant à la requete
99
	 */
5 aperonnet 100
	private int nbElements = 0;
101
 
2 aperonnet 102
	/**
5 aperonnet 103
	 * "Presse papier" pour les images qui permet de garder en mémoire une
104
	 * sélection
105
	 */
106
	private Vector<String> selectionImages = new Vector<String>(0);
107
 
108
	/**
2 aperonnet 109
	 * Retourne une instance de manière unique
5 aperonnet 110
	 *
111
	 * @param im
112
	 *            le médiateur à associer
2 aperonnet 113
	 * @return l'instance du modèle
114
	 */
5 aperonnet 115
	static ImageModele Instance(ImageMediateur im) {
2 aperonnet 116
		// si le modèle n'est pas encore instancié
5 aperonnet 117
		if (!estInstancie) {
2 aperonnet 118
			// on en crée un nouveau
5 aperonnet 119
			estInstancie = true;
2 aperonnet 120
			thisModele = new ImageModele(im);
121
		}
5 aperonnet 122
 
2 aperonnet 123
		// sinon on retourne le "pointeur" vers le modèle lui-même
5 aperonnet 124
		return thisModele;
2 aperonnet 125
 
126
	}
5 aperonnet 127
 
2 aperonnet 128
	/**
129
	 * Le constructeur est privé et seule la méthode instance y accède
5 aperonnet 130
	 *
131
	 * @param im
132
	 *            le médiateur à associer
2 aperonnet 133
	 */
134
	private ImageModele(ImageMediateur im) {
5 aperonnet 135
 
136
		iMediateur = im;
137
		config = new Configuration();
2 aperonnet 138
	}
5 aperonnet 139
 
2 aperonnet 140
	/**
141
	 * Accesseur pour le médiateur
5 aperonnet 142
	 *
2 aperonnet 143
	 * @return le médiateur associé
144
	 */
5 aperonnet 145
	public ImageMediateur getIMediateur() {
146
		return iMediateur;
2 aperonnet 147
	}
5 aperonnet 148
 
2 aperonnet 149
	/**
150
	 * Appelle le DAO asynchrone pour obtenir la liste des images
5 aperonnet 151
	 *
152
	 * @param r
153
	 *            le rafraichissable auxquel on enverra les données
2 aperonnet 154
	 */
5 aperonnet 155
	public void obtenirNombrePhotoGalerie(Rafraichissable r) {
156
 
157
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
158
 
159
		int tailleFiltres = valeursFiltres.length;
160
 
965 aurelien 161
		String[][] criteres = new String[tailleFiltres][2];
5 aperonnet 162
 
965 aurelien 163
		String[] utilisateur = {
5 aperonnet 164
				"" + getIMediateur().getIdentifiant() };
165
		criteres[0] = utilisateur;
166
 
167
 
168
		for (int i = 0; i < valeursFiltres.length; i++) {
965 aurelien 169
			criteres[i] = valeursFiltres[i];
5 aperonnet 170
		}
171
 
172
		// on les crée un DAO auquel on les transmet et qui demande le nombre
173
		// d'images correspondantes (pour les pages)
174
		NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);
175
		niaDAO.obtenirNombreImages(this, criteres);
176
	}
177
 
2 aperonnet 178
	public void obtenirPhotoGalerie(Rafraichissable r)
179
	{
5 aperonnet 180
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
2 aperonnet 181
 
5 aperonnet 182
		int tailleFiltres = valeursFiltres.length;
2 aperonnet 183
 
5 aperonnet 184
		String[][] criteres2 = new String[tailleFiltres + 2][2];
2 aperonnet 185
 
965 aurelien 186
		String[] limite = { "limite", "" + taillePage };
187
		String[] taillePage = { "numero_page", "" + pageEncours };
2 aperonnet 188
 
5 aperonnet 189
		criteres2[0] = limite;
190
		criteres2[1] = taillePage;
191
 
192
		for (int i = 0; i < valeursFiltres.length; i++) {
193
			criteres2[i + 2] = valeursFiltres[i];
2 aperonnet 194
		}
195
 
5 aperonnet 196
		// et on crée un DAO auquel on les transmet et qui envoie une requete
197
		// pour recevoir les images
2 aperonnet 198
		ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);
5 aperonnet 199
		liaDAO.ObtenirListeImages(this, criteres2);
2 aperonnet 200
	}
5 aperonnet 201
 
2 aperonnet 202
	/**
5 aperonnet 203
	 * Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et
204
	 * lancer l'interface appropriée
2 aperonnet 205
	 */
206
	@SuppressWarnings("static-access")
142 aurelien 207
	public void uploaderImages(boolean multiple) {
5 aperonnet 208
		ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);
142 aurelien 209
		if(multiple) {
210
			IuADaO.appelerUploadMultiple();
211
		}
212
		else
213
		{
214
			IuADaO.appelerUploadSimple();
215
		}
2 aperonnet 216
	}
5 aperonnet 217
 
2 aperonnet 218
	/**
219
	 * Met à jour la liste des images à partir d'un objet
5 aperonnet 220
	 *
221
	 * @param o
222
	 *            la nouvelle liste d'image
2 aperonnet 223
	 */
5 aperonnet 224
	public void rafraichirListeImage(Object o) {
225
		cacheImage = (ListeImageCarnet) o;
2 aperonnet 226
	}
5 aperonnet 227
 
2 aperonnet 228
	/**
229
	 * Met à jour l'arbre des mots clés à partir d'un objet
5 aperonnet 230
	 *
231
	 * @param o
232
	 *            le nouvel arbre de mots clés
2 aperonnet 233
	 */
5 aperonnet 234
	public void rafraichirArbreMotsCles(Object o) {
235
		arbreMotsCles = (com.gwtext.client.data.Tree) o;
2 aperonnet 236
	}
5 aperonnet 237
 
2 aperonnet 238
	/**
5 aperonnet 239
	 * Met à jour la table de correspondance mots clés / ids à partir d'un objet
240
	 *
241
	 * @param o
242
	 *            la nouvelle table des mots clés
2 aperonnet 243
	 */
244
	@SuppressWarnings("unchecked")
5 aperonnet 245
	public void rafraichirMotsCles(Object o) {
246
		if (o instanceof HashMap) {
247
			motsCles = (HashMap<String, String>) o;
2 aperonnet 248
		}
249
	}
5 aperonnet 250
 
2 aperonnet 251
	/**
5 aperonnet 252
	 * Va chercher les métadonnées associées à une image dans la liste des
253
	 * images chargée dans le modèle
254
	 *
255
	 * @param r
256
	 *            le rafraichissable auquel on enverra les informations
257
	 * @param id
258
	 *            l'identifiant de l'image
2 aperonnet 259
	 */
5 aperonnet 260
	public void obtenirMetadonnees(Rafraichissable r, String id) {
261
		ImageCarnet im = (ImageCarnet) cacheImage.get(id);
262
 
263
		Object meta[] = new Object[3];
264
		meta[0] = im.getMetadonnesExif();
265
		meta[1] = im.getMetadonnesIptc();
266
		meta[2] = im.getInfoGenerales();
267
 
268
		r.rafraichir(meta, false);
2 aperonnet 269
	}
5 aperonnet 270
 
2 aperonnet 271
	/**
5 aperonnet 272
	 * Va chercher les mots clés associés à une image dans la liste des images
273
	 * chargée dans le modèle
274
	 *
275
	 * @param r
276
	 *            le rafraichissable auquel on enverra les informations
277
	 * @param id
278
	 *            l'identifiant de l'image
2 aperonnet 279
	 */
5 aperonnet 280
	public void obtenirMotsClesId(Rafraichissable r, String id) {
281
 
1018 aurelien 282
		String[] motsClesIdTab = getMotsClesId(id);
5 aperonnet 283
		r.rafraichir(motsClesIdTab, false);
2 aperonnet 284
	}
674 aurelien 285
 
1018 aurelien 286
	public String[] getMotsClesId(String idImage) {
287
		ImageCarnet im = cacheImage.get(idImage);
288
		String motsClesId = im.getMotsCles();
289
		String[] motsClesIdTab = motsClesId.split(",");
290
 
291
		return motsClesIdTab;
292
	}
293
 
674 aurelien 294
	/**
295
	 * Va chercher le nom du mot clé associé à un id dans le cache local
296
	 *
297
	 * @param String id
298
	 *            id du mot clé
299
	 * @return le mot clé associé à l'identifiant
300
	 */
301
	public String obtenirTexteMotCle(String id) {
302
 
303
		String correspondanceId = "";
304
 
305
		String motCleTexte = motsCles.get(id);
306
 
307
		if(motCleTexte != null) {
308
			correspondanceId = motCleTexte;
309
		}
310
 
311
		return correspondanceId;
312
	}
1009 aurelien 313
 
314
	/**
315
	 * Construit une chaine contenant le texte des mots clés séparés par des virgules
316
	*/
317
	public String renvoyerChaineMotClesTexte(ImageCarnet ic) {
318
		String chaineMotsCles = ic.getMotsCles();
319
		String[] tabMotsCles = chaineMotsCles.split(",");
320
		String chaineMotsClesTexte = "";
321
		for (int i = 0; i < tabMotsCles.length; i++) {
322
			chaineMotsClesTexte += motsCles.get(tabMotsCles[i]);
323
			chaineMotsClesTexte += (i != tabMotsCles.length - 1) ? "," : "";
324
		}
325
		return chaineMotsClesTexte;
326
	}
5 aperonnet 327
 
2 aperonnet 328
	/**
5 aperonnet 329
	 * Met à jour la liste des images en local et appelle le DAO de mise à jour
330
	 * pour les commentaires et la date des images selectionnées
331
	 *
332
	 * @param commentaires
333
	 *            le commentaire à appliquer
334
	 * @param date
335
	 *            la date à appliquer
336
	 * @param ids
337
	 *            les identifiants des images selectionnées
2 aperonnet 338
	 */
5 aperonnet 339
	public void mettreAJourCacheImage(String commentaires, String date,
340
			String note, String ids[]) {
341
		for (int i = 0; i < ids.length; i++) {
342
			String key = ids[i];
343
			ImageCarnet ic = cacheImage.get(key);
344
			ic.miseAJourInfoGenerales(commentaires, date, note);
345
			mettreAjourBaseDeDonneesImageCarnet(ic);
346
		}
347
 
2 aperonnet 348
	}
5 aperonnet 349
 
2 aperonnet 350
	/**
351
	 * Ajoute un nouveau mot clés à la liste des mots clés locale
5 aperonnet 352
	 *
353
	 * @param text
354
	 *            le mot clé
355
	 * @param id
356
	 *            l'identifiant du mot clé
2 aperonnet 357
	 */
5 aperonnet 358
	public void mettreAjourMotsClesId(String text, String id) {
359
		motsCles.put(id, text);
2 aperonnet 360
	}
5 aperonnet 361
 
2 aperonnet 362
	/**
5 aperonnet 363
	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes
364
	 * les informations des images modifiées par l'utilisateur
2 aperonnet 365
	 */
5 aperonnet 366
	public void mettreAJourBaseDeDonneesListeImageCarnet() {
2 aperonnet 367
		ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);
5 aperonnet 368
 
2 aperonnet 369
		liDaO.SynchroniserBaseDeDonnees(cacheImage);
370
	}
5 aperonnet 371
 
2 aperonnet 372
	/**
5 aperonnet 373
	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes
374
	 * les informations d'une image donnée
375
	 *
376
	 * @param ic
377
	 *            l'image à synchroniser avec la base
2 aperonnet 378
	 */
5 aperonnet 379
	public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) {
2 aperonnet 380
		ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);
5 aperonnet 381
		iaDaO.SynchroniserBaseDeDonnees(ic);
2 aperonnet 382
	}
383
 
384
	/**
5 aperonnet 385
	 * Supprime les images données du cache local et appelle le DAO qui les
386
	 * supprime de la base de données
387
	 *
388
	 * @param ids
389
	 *            les identifiants des images selectionnées
2 aperonnet 390
	 */
5 aperonnet 391
	public void supprimerImages(String[] ids) {
392
		String rids[] = new String[ids.length];
393
		ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);
394
 
395
		for (int i = 0; i < ids.length; i++) {
396
			String key = ids[i];
397
			ImageCarnet ic = cacheImage.get(key);
398
			rids[i] = ic.getId();
399
 
400
			cacheImage.remove(key);
2 aperonnet 401
		}
5 aperonnet 402
 
403
		if (rids.length != 0) {
2 aperonnet 404
			liDao.supprimerBaseDeDonnees(rids);
5 aperonnet 405
		}
2 aperonnet 406
	}
407
 
408
	/**
5 aperonnet 409
	 * Met à jour les données locales suivant le type des nouvelles données et
410
	 * appelle le médiateur pour le notifier de la mise à jour
2 aperonnet 411
	 */
5 aperonnet 412
	public void rafraichir(Object nouvelleDonnees,
413
			boolean repandreRafraichissement) {
2 aperonnet 414
		// si l'on a reçu une liste d'images
5 aperonnet 415
		if (nouvelleDonnees instanceof ListeImageCarnet) {
416
			ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees;
400 aurelien 417
			Object[][] photoData = new Object[data.size()][13];
5 aperonnet 418
			int i = 0;
2 aperonnet 419
 
5 aperonnet 420
			if (data.size() == 0) {
421
				pageEncours = 0;
422
			}
423
 
598 aurelien 424
			// on la parse et on récupère les informations qui nous interessent
5 aperonnet 425
			for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {
426
				ImageCarnet im = data.get(it.next());
427
				photoData[i][0] = im.getOrdre();
212 aurelien 428
				photoData[i][1] = im.getNomOriginal();
429
				photoData[i][2] = im.getDate();
430
				photoData[i][3] = im.getIptcCity();
989 aurelien 431
				photoData[i][4] = im.getFabriquantAppareil() + " " + im.getModeleAppareil();
659 aurelien 432
				photoData[i][5] = im.getUrlFormatListe();
433
				photoData[i][6] = im.getUrlFormatGalerie();
434
				photoData[i][7] = im.getUrlFormatZoom();
212 aurelien 435
				photoData[i][8] = im.getNote();
436
				photoData[i][9] = im.getId();
437
				photoData[i][10] = im.getTailleImage()[1];
438
				photoData[i][11] = im.getTailleImage()[0];
400 aurelien 439
				photoData[i][12] = im.getIdsObsAssociees();
5 aperonnet 440
 
441
				i++;
442
			}
443
 
444
			// creation du store qui les contient
445
			FieldDef defNumImage = new IntegerFieldDef("num_image");
212 aurelien 446
			FieldDef defNomImage = new StringFieldDef("nom_original");
5 aperonnet 447
			FieldDef defDatImage = new StringFieldDef("dat_image");
448
			FieldDef defLieImage = new StringFieldDef("lie_image");
449
			FieldDef defAppImage = new StringFieldDef("app_image");
450
			FieldDef defUrlImageS = new StringFieldDef("url_image_S");
451
			FieldDef defUrlImageM = new StringFieldDef("url_image_M");
452
			FieldDef defUrlImage = new StringFieldDef("url_image");
453
			FieldDef defNoteImage = new IntegerFieldDef("note_image");
454
			FieldDef defIdImage = new IntegerFieldDef("id_image");
140 aurelien 455
			FieldDef defTailleX = new IntegerFieldDef("taille_x");
456
			FieldDef defTailleY = new IntegerFieldDef("taille_y");
400 aurelien 457
			FieldDef defObsAssociees = new StringFieldDef("obs_associees");
212 aurelien 458
			FieldDef[] defTab = { defNumImage,defNomImage, defDatImage, defLieImage,
5 aperonnet 459
					defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
400 aurelien 460
					defNoteImage, defIdImage, defTailleX, defTailleY, defObsAssociees };
5 aperonnet 461
			RecordDef rd = new RecordDef(defTab);
462
 
463
			final MemoryProxy dataProxy = new MemoryProxy(photoData);
464
			final ArrayReader reader = new ArrayReader(rd);
465
 
466
			final Store photoStore = new Store(dataProxy, reader);
467
 
468
			rafraichirListeImage(nouvelleDonnees);
469
 
470
			st = photoStore;
471
			st.load();
472
 
473
			// par défaut le store est trié sur le numéro d'image
474
			st.sort("num_image");
475
 
476
			// si on doit répandre les données, on notifie le médiateur qui les
477
			// distribuera à son tour
478
			if (repandreRafraichissement) {
479
				getIMediateur().synchroniserDonneesZoomListeGalerie(st, this);
480
			}
2 aperonnet 481
		}
5 aperonnet 482
 
2 aperonnet 483
		// si on reçoit un tableau JSON
5 aperonnet 484
		if (nouvelleDonnees instanceof JSONArray) {
2 aperonnet 485
			// alors on a reçu les informations sur les mots clés
5 aperonnet 486
			JSONArray reponse = (JSONArray) nouvelleDonnees;
487
 
2 aperonnet 488
			final int taillemax = reponse.size();
5 aperonnet 489
 
2 aperonnet 490
			// si le tableau est vide
5 aperonnet 491
			if (taillemax == 0) {
2 aperonnet 492
				// on crée un arbre vide
5 aperonnet 493
				TreeNode root = new TreeNode();
494
				root.setId("racine");
495
				root.setText("Tags");
496
				String[] usObj = { "Tags", "racine" };
497
				root.setUserObject(usObj);
498
				arbreMotsCles.setRootNode(root);
2 aperonnet 499
			}
674 aurelien 500
 
501
			HashMap<String, String> motsCles = new HashMap<String, String>(taillemax);
5 aperonnet 502
 
2 aperonnet 503
			// pour chacun des élements du tableau
5 aperonnet 504
			for (int j = 0; j < taillemax; j++) {
2 aperonnet 505
				// on extrait les élements du tableau
5 aperonnet 506
				if (reponse.get(j).isObject() != null) {
507
					JSONObject noeud = (JSONObject) reponse.get(j);
508
 
1283 aurelien 509
					String id_noeud = noeud.get("id_mot_cle_image")
5 aperonnet 510
							.isString().stringValue();
965 aurelien 511
					String mot_cle = noeud.get("mot_cle").isString()
5 aperonnet 512
							.stringValue();
1283 aurelien 513
					String parent = noeud.get("ce_mot_cle_image_parent").isString()
5 aperonnet 514
							.stringValue();
515
 
516
					String[] usObj = { mot_cle, id_noeud };
517
 
518
					// et on construit l'arbre à partir de la racine (qui est
659 aurelien 519
					// toujours le premier élément)
5 aperonnet 520
					if (id_noeud.equals("racine")) {
521
						TreeNode root = new TreeNode();
522
						root.setId(id_noeud);
523
						root.setText(mot_cle);
524
						root.setUserObject(usObj);
525
						arbreMotsCles.setRootNode(root);
526
					} else {
527
						// et en ajoutant les noeuds un à un (qui sont renvoyé
528
						// dans l'ordre hierarchique de leur niveau
2 aperonnet 529
						// ce qui permet de les traiter séquentiellement)
5 aperonnet 530
						TreeNode node = new TreeNode();
531
						node.setId(id_noeud);
532
						node.setText(mot_cle);
533
						node.setChecked(false);
534
						Node parentNode = arbreMotsCles.getNodeById(parent);
535
						node.setUserObject(usObj);
536
						parentNode.appendChild(node);
2 aperonnet 537
					}
674 aurelien 538
 
539
					motsCles.put(id_noeud, mot_cle);
2 aperonnet 540
				}
5 aperonnet 541
			}
674 aurelien 542
 
543
 
5 aperonnet 544
			// enfin on met à jour l'arbre des mots clés contenu dans le modèle
545
			rafraichirArbreMotsCles(arbreMotsCles);
674 aurelien 546
			// la table de hachage
547
			rafraichirMotsCles(motsCles);
5 aperonnet 548
			// et on notifie le médiateur de la mise à jour en lui passant une
549
			// copie des données
550
			getIMediateur().rafraichirArbreMotsCles(arbreMotsCles);
2 aperonnet 551
		}
5 aperonnet 552
 
2 aperonnet 553
		// Si on reçoit un tableau d'entiers
5 aperonnet 554
		// c'est un tableau d'un seul entier qui est le nombre d'images
555
		// correspondant aux critères
556
		if (nouvelleDonnees instanceof int[]) {
557
			int[] pages = (int[]) nouvelleDonnees;
558
 
559
			// on calcule le nombre de pages nécessaires et on les met à jour
560
			// dans le modèle
561
			pageMax = calculerNbPages(pages[0]);
562
			nbElements = pages[0];
563
 
564
			// et on notifie de le mediateur du changement des valeurs
565
			getIMediateur().changerPageMaxEtCourante(pageMax, pageEncours,
566
					taillePage, pages[0]);
2 aperonnet 567
 
5 aperonnet 568
			obtenirPhotoGalerie(this) ;
2 aperonnet 569
		}
99 jpm 570
 
571
		if(nouvelleDonnees instanceof ListeObservation) {
572
 
158 aurelien 573
			getIMediateur().rafraichirMiniListeObservations((ListeObservation)nouvelleDonnees) ;
99 jpm 574
		}
158 aurelien 575
 
576
		if(nouvelleDonnees instanceof Tree) {
577
			rafraichirArbreMotsCles(nouvelleDonnees);
578
			getIMediateur().rafraichirArbreMotsCles((Tree)nouvelleDonnees);
579
		}
2 aperonnet 580
	}
5 aperonnet 581
 
2 aperonnet 582
	/**
583
	 * Affiche les paires / valeur de tous les mots clés stockés
584
	 */
5 aperonnet 585
	public void afficherMotsCles() {
586
		for (Iterator<String> it = motsCles.keySet().iterator(); it.hasNext();) {
587
			String key = it.next();
588
			String valeur = (String) motsCles.get(key);
589
			System.out.println("clé : " + key + " valeur : " + valeur);
2 aperonnet 590
		}
591
	}
592
 
593
	/**
5 aperonnet 594
	 * Met à jour les mots clés associés à une image et appelle le DAO pour
595
	 * synchroniser la base de données
596
	 *
597
	 * @param ids
598
	 *            les identifiants des images selectionnées
599
	 * @param motsClesEnCours
600
	 *            les mots clés à appliquer aux images
601
	 * @param arbreMC
602
	 *            l'arbre de mots clés en cours
2 aperonnet 603
	 */
5 aperonnet 604
	public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,
605
			com.gwtext.client.data.Tree arbreMC) {
971 aurelien 606
 
607
		String idImgs = "";
5 aperonnet 608
		for (int i = 0; i < ids.length; i++) {
609
			if (cacheImage.containsKey(ids[i])) {
610
				ImageCarnet ic = (ImageCarnet) cacheImage.get(ids[i]);
611
				ic.mettreAjourMotsCles(motsClesEnCours);
2 aperonnet 612
			}
971 aurelien 613
 
614
			idImgs += ids[i];
615
			idImgs += (i < (ids.length - 1)) ? ",": "";
2 aperonnet 616
		}
971 aurelien 617
 
618
		LiaisonMotsClesImageAsynchroneDAO liMcDao = new LiaisonMotsClesImageAsynchroneDAO(this);
619
		liMcDao.modifier(this, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idImgs, motsClesEnCours);
5 aperonnet 620
 
621
		rafraichirArbreMotsCles(arbreMC);
2 aperonnet 622
	}
5 aperonnet 623
 
2 aperonnet 624
	/**
5 aperonnet 625
	 * Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la
626
	 * base de données
2 aperonnet 627
	 */
5 aperonnet 628
	public void initialiserArbreMotsCles() {
137 aurelien 629
 
1018 aurelien 630
			MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
137 aurelien 631
			MCDao.obtenirListeMotsCles(this);
2 aperonnet 632
	}
5 aperonnet 633
 
2 aperonnet 634
	/**
5 aperonnet 635
	 * Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable
636
	 * donné, qui le demande
637
	 *
638
	 * @param r
639
	 *            le rafraichissable demandeur de l'arbre
2 aperonnet 640
	 */
5 aperonnet 641
	public void obtenirArbreMotCle(Rafraichissable r) {
137 aurelien 642
			r.rafraichir(arbreMotsCles, false);
2 aperonnet 643
	}
644
 
645
	/**
5 aperonnet 646
	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
647
	 * fait la mise à jour de l'arbre des mots clés dans la base
648
	 *
649
	 * @param n
650
	 *            le nouveau noeud contenant le mot clé
651
	 * @param arbreMC
652
	 *            l'arbre des mots cles en cours
2 aperonnet 653
	 */
5 aperonnet 654
	public void ajouterMotCleDansArbre(TreeNode n,
655
			com.gwtext.client.data.Tree arbreMC) {
1018 aurelien 656
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
5 aperonnet 657
 
658
		String[] usObj = (String[]) n.getUserObject();
659
		String motCle = usObj[0];
660
		String id = usObj[1];
661
		String parentId = "";
662
 
663
		if (!id.equals("racine")) {
664
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
665
			parentId = parentUsObj[1];
666
		} else {
667
			parentId = "racine";
2 aperonnet 668
		}
5 aperonnet 669
 
670
		rafraichirArbreMotsCles(arbreMC);
1018 aurelien 671
		mettreAjourMotsClesId(motCle, id);
5 aperonnet 672
 
673
		String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
674
				+ motCle + "&id=" + id + "&parent=" + parentId;
675
		MCDao.ajouterBaseDeDonnees(nouveauMotCle);
2 aperonnet 676
	}
677
 
678
	/**
5 aperonnet 679
	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
680
	 * supprimer les mots clés associés dans la base
681
	 *
682
	 * @param n
683
	 *            le noeud à supprimer
684
	 * @param arbreMC
685
	 *            l'arbre des mots clés en cours
2 aperonnet 686
	 */
5 aperonnet 687
	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
688
 
1018 aurelien 689
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
5 aperonnet 690
 
691
		String[] usObj = (String[]) n.getUserObject();
692
		String id = usObj[1];
693
 
694
		MCDao.supprimerBaseDeDonnees(id);
695
 
2 aperonnet 696
	}
697
 
698
	/**
5 aperonnet 699
	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
700
	 * DAO qui synchronise la modification dans la base de données
701
	 *
702
	 * @param n
703
	 *            le noeud modifié
704
	 * @param arbreMC
705
	 *            l'arbre des mots clés en cours
2 aperonnet 706
	 */
5 aperonnet 707
	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
708
 
1018 aurelien 709
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
5 aperonnet 710
 
711
		String[] usObj = (String[]) n.getUserObject();
712
		String motCle = usObj[0];
713
		String id = usObj[1];
714
		String parentId = "";
715
 
716
		if (!id.equals("racine")) {
717
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
718
			parentId = parentUsObj[1];
719
		} else {
720
			parentId = "racine";
2 aperonnet 721
		}
5 aperonnet 722
 
723
		rafraichirArbreMotsCles(arbreMC);
724
 
725
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
726
				+ parentId;
727
		MCDao.modifierBaseDeDonnees(motCleModifie);
728
 
2 aperonnet 729
	}
5 aperonnet 730
 
2 aperonnet 731
	/**
5 aperonnet 732
	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
733
	 * reorganise l'arbre dans la base de donnees suivant le changement
734
	 *
735
	 * @param n
736
	 *            le noeud deplace (et son sous arbre associe)
737
	 * @param arbreMC
738
	 *            l'arbre des mots cles en cours
2 aperonnet 739
	 */
5 aperonnet 740
	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
1018 aurelien 741
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
5 aperonnet 742
 
743
		String[] usObj = (String[]) n.getUserObject();
744
		String motCle = usObj[0];
745
		String id = usObj[1];
746
		String parentId = "";
747
		if (!id.equals("racine")) {
748
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
749
			parentId = parentUsObj[1];
750
		} else {
751
			parentId = "racine";
2 aperonnet 752
		}
5 aperonnet 753
 
754
		rafraichirArbreMotsCles(arbreMC);
755
 
756
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
757
				+ parentId;
758
		MCDao.deplacerBaseDeDonnees(motCleModifie);
2 aperonnet 759
	}
5 aperonnet 760
 
2 aperonnet 761
	/**
5 aperonnet 762
	 * Change le numéro de la page en cours et envoie une demande de mise à jour
763
	 * des données
764
	 *
765
	 * @param nouvellePageCourante
766
	 *            la nouvelle page à afficher
2 aperonnet 767
	 */
5 aperonnet 768
	public void changerNumeroPage(int nouvellePageCourante) {
769
		pageEncours = nouvellePageCourante;
770
		obtenirNombrePhotoGalerie(this);
2 aperonnet 771
	}
5 aperonnet 772
 
2 aperonnet 773
	/**
5 aperonnet 774
	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements
775
	 * donnés en fonction de la taille de page en cours
776
	 *
777
	 * @param nbElements
778
	 *            le nombre d'élements total
779
	 * @return le nombre de pages
2 aperonnet 780
	 */
5 aperonnet 781
	public int calculerNbPages(int nbElements) {
782
		// A cause de la betise de java pour les conversion implicite on fait
783
		// quelques conversions manuellement
2 aperonnet 784
		// pour eviter qu'il arrondisse mal la division
5 aperonnet 785
		// nombre de pages = (nombre d'element / taille de la page) arrondie à
786
		// l'entier superieur
787
		double nPage = (1.0 * nbElements) / (1.0 * taillePage);
788
		double nPageRound = Math.ceil(nPage);
789
		Double nPageInt = new Double(nPageRound);
790
 
2 aperonnet 791
		// on convertit en entier
5 aperonnet 792
		return nPageInt.intValue();
2 aperonnet 793
	}
5 aperonnet 794
 
2 aperonnet 795
	/**
796
	 * Recalcule la page en cours lors du changement du nombre d'élements
5 aperonnet 797
	 *
798
	 * @param nbElements
799
	 *            le nombre d'élements total
2 aperonnet 800
	 * @return la nouvelle page encours
801
	 */
5 aperonnet 802
	public int calculerPageCourante(int nbElements) {
2 aperonnet 803
		// on calcule le nombre de page
5 aperonnet 804
		int nouvelNbPages = calculerNbPages(nbElements);
2 aperonnet 805
		// la nouvelle page en cours
5 aperonnet 806
		double nPageCourante = (1.0 * pageEncours) / (1.0 * pageMax)
807
				* (1.0 * nouvelNbPages);
808
 
2 aperonnet 809
		// on arrondit au supérieur
5 aperonnet 810
		double nPageRound = Math.ceil(nPageCourante);
811
		Double nPageInt = new Double(nPageRound);
812
 
2 aperonnet 813
		// on convertit en entier
5 aperonnet 814
		return Math.abs(nPageInt.intValue());
2 aperonnet 815
	}
5 aperonnet 816
 
2 aperonnet 817
	/**
5 aperonnet 818
	 * Change la taille de page et recalcule la page encours
819
	 *
820
	 * @param nouvelleTaillePage
821
	 *            la nouvelle taille de page à utiliser
2 aperonnet 822
	 */
5 aperonnet 823
	public void changerTaillePage(int nouvelleTaillePage) {
824
		taillePage = nouvelleTaillePage;
825
		pageEncours = calculerPageCourante(nbElements);
826
		obtenirNombrePhotoGalerie(this);
2 aperonnet 827
	}
690 aurelien 828
 
829
	/**
830
	 * Met la valeur de la page en cours à la dernière
831
	 */
832
	public void setDernierePage() {
833
		changerNumeroPage(pageMax);
834
	}
5 aperonnet 835
 
2 aperonnet 836
	/**
5 aperonnet 837
	 * Notifie le mediateur que l'upload ou le download est termine et qu'il
838
	 * faut rafraichir les vues avec les nouvelles données
2 aperonnet 839
	 */
5 aperonnet 840
	public void requeteTerminee() {
841
		getIMediateur().demasquerChargement();
842
		getIMediateur().rafraichirToutesVues();
2 aperonnet 843
	}
844
 
845
	/**
846
	 * Obtient l'identifiant de l'utilisateur auprès du médiateur
5 aperonnet 847
	 *
2 aperonnet 848
	 * @return id de l'utilisateur
849
	 */
850
	public String getIdentifiant() {
5 aperonnet 851
 
852
		return getIMediateur().getIdentifiant();
2 aperonnet 853
	}
854
 
855
	/**
856
	 * renvoie la taille d'une image grâce à son identifiant
5 aperonnet 857
	 *
858
	 * @param id
859
	 *            l'identifiant de l'image
2 aperonnet 860
	 * @return un tableau contenant la longueur et la hauteur de l'image
861
	 */
862
	public String[] obtenirTailleImage(String id) {
5 aperonnet 863
 
864
		return (cacheImage.get(id)).getTailleImage();
865
 
2 aperonnet 866
	}
867
 
868
	/**
5 aperonnet 869
	 * Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il
2 aperonnet 870
	 * renvoie la note associée au rafrachissable qui la demande
5 aperonnet 871
	 *
872
	 * @param r
873
	 *            le rafraichissable demandeur de l'information
874
	 * @param id
875
	 *            l'identifiant del'image
2 aperonnet 876
	 */
877
	public void obtenirNote(Rafraichissable r, String id) {
5 aperonnet 878
 
879
		r.rafraichir((cacheImage.get(id)).getNote(), true);
880
 
2 aperonnet 881
	}
5 aperonnet 882
 
2 aperonnet 883
	/**
884
	 * Accesseur pour la configuration en cours d'utilisation
5 aperonnet 885
	 *
2 aperonnet 886
	 * @return la configuration
887
	 */
888
	public Configuration getConfig() {
5 aperonnet 889
 
890
		return config;
891
	}
892
 
893
	/**
894
	 * Ajoute des images à la selection en cours
895
	 *
896
	 * @param ids
897
	 *            les identifiants des images à ajouter
898
	 */
899
	public void ajouterImagesSelection(String[] ids) {
900
 
901
		for (int i = 0; i < ids.length; i++) {
142 aurelien 902
 
903
			String idImg = cacheImage.get(ids[i]).getId();
904
			selectionImages.add(idImg);
5 aperonnet 905
		}
906
	}
907
 
173 aurelien 908
	public int getCompteSelection() {
909
		return selectionImages.size();
910
	}
911
 
5 aperonnet 912
	/**
913
	 * Vide la selection en cours
914
	 */
915
	public void viderSelection() {
916
		selectionImages.clear();
917
	}
918
 
919
	public String renvoyerSelection() {
920
 
921
		String selection = "";
2 aperonnet 922
 
5 aperonnet 923
		if(selectionImages.size() <= 0)
924
		{
925
			selection += "-255" ;
926
		}
927
		else
928
		{
929
			for (Iterator<String> it = selectionImages.iterator(); it.hasNext();) {
930
 
931
				String idEncours = it.next();
932
				selection += idEncours + ",";
933
			}
934
		}
935
 
936
		return selection;
2 aperonnet 937
	}
5 aperonnet 938
 
939
	public void lierImagesObervations(String idsObs, String idsImg) {
940
 
941
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
942
		lienDAO.lierImageBaseDeDonnees(idsImg, idsObs) ;
943
 
944
	}
945
 
81 jpm 946
	public void obtenirLiaisonObservations(ImageMediateur imageMediateur,
947
			String id) {
948
 
949
		String imgId = cacheImage.get(id).getId() ;
950
 
951
		LienImageAsynchroneDAO lienDao = new LienImageAsynchroneDAO(this) ;
952
		lienDao.obtenirLiaisonsImagesObservations(this, imgId) ;
953
 
954
	}
955
 
598 aurelien 956
	public void supprimerLiaisonImages(String[] idsImg, String idObs) {
104 jpm 957
 
598 aurelien 958
		String chaineIdImg = "";
104 jpm 959
 
598 aurelien 960
		for(int i = 0; i < idsImg.length; i++) {
961
			String idImg = cacheImage.get(idsImg[i]).getId() ;
962
			chaineIdImg += ","+idImg;
963
		}
964
 
965
		chaineIdImg = chaineIdImg.replaceFirst(",", "");
966
 
104 jpm 967
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
598 aurelien 968
		lienDAO.supprimerLienImageObservation(chaineIdImg, idObs) ;
104 jpm 969
	}
970
 
413 aurelien 971
	public void obtenirMiniListeObservations(Rafraichissable r, String[] critere, int taillePage, int numeroPage) {
972
 
973
		String[][] criteres = {{critere[0],critere[1]},{"limite",""+taillePage},{"numero_page",""+numeroPage}} ;
974
 
975
		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
976
		ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
977
		loaDAO.obtenirListeObservation(r, iMediateur.getIdentifiant(), criteres);
978
 
979
	}
980
 
981
	public void obtenirNombreMiniListeObservations(Rafraichissable r, String[] critere) {
982
 
983
		String[][] criteres = {{critere[0],critere[1]}} ;
984
 
985
		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
986
		NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this);
987
		noaDAO.obtenirNombreObservation(r, iMediateur.getIdentifiant(), criteres);
988
 
989
	}
990
 
659 aurelien 991
	public void obtenirDatesImages(Rafraichissable r) {
992
		ListeDateImageAsynchroneDAO lDateDao = new ListeDateImageAsynchroneDAO(this);
993
		lDateDao.obtenirListeDate(r, iMediateur.getIdentifiant());
994
	}
995
 
2 aperonnet 996
}