Subversion Repositories eFlore/Applications.cel

Rev

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