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;
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
	}
2726 aurelien 147
 
148
	public String[][] obtenirFiltresPourComptage() {
5 aperonnet 149
 
150
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
151
 
152
		int tailleFiltres = valeursFiltres.length;
153
 
965 aurelien 154
		String[][] criteres = new String[tailleFiltres][2];
5 aperonnet 155
 
965 aurelien 156
		String[] utilisateur = {
5 aperonnet 157
				"" + getIMediateur().getIdentifiant() };
158
		criteres[0] = utilisateur;
159
 
160
 
161
		for (int i = 0; i < valeursFiltres.length; i++) {
965 aurelien 162
			criteres[i] = valeursFiltres[i];
5 aperonnet 163
		}
2726 aurelien 164
 
165
		return criteres;
166
	}
167
 
168
	public String[][] obtenirFiltresPourDonnees() {
5 aperonnet 169
 
2726 aurelien 170
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
171
 
172
		int tailleFiltres = valeursFiltres.length;
173
 
174
		String[][] criteres2 = new String[tailleFiltres + 2][2];
175
 
176
		String[] limite = { "limite", "" + taillePage };
177
		String[] taillePage = { "numero_page", "" + pageEncours };
178
 
179
		criteres2[0] = limite;
180
		criteres2[1] = taillePage;
181
 
182
		for (int i = 0; i < valeursFiltres.length; i++) {
183
			criteres2[i + 2] = valeursFiltres[i];
184
		}
185
 
186
		return valeursFiltres;
187
	}
188
 
189
	/**
190
	 * Appelle le DAO asynchrone pour obtenir la liste des images
191
	 *
192
	 * @param r
193
	 *            le rafraichissable auxquel on enverra les données
194
	 */
195
	public void obtenirNombrePhotoGalerie(Rafraichissable r) {
196
 
197
		String[][] criteres = obtenirFiltresPourComptage();
198
 
5 aperonnet 199
		// on les crée un DAO auquel on les transmet et qui demande le nombre
200
		// d'images correspondantes (pour les pages)
201
		NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);
202
		niaDAO.obtenirNombreImages(this, criteres);
203
	}
204
 
2 aperonnet 205
	public void obtenirPhotoGalerie(Rafraichissable r)
206
	{
5 aperonnet 207
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
2 aperonnet 208
 
5 aperonnet 209
		int tailleFiltres = valeursFiltres.length;
2 aperonnet 210
 
2726 aurelien 211
		String[][] criteres2 = new String[tailleFiltres + 4][2];
2 aperonnet 212
 
2726 aurelien 213
		String[] tri = { "tri", "" + getIMediateur().getTri() };
214
		String[] triDir = { "dir", "" + getIMediateur().getDirectionTri()};
215
 
965 aurelien 216
		String[] limite = { "limite", "" + taillePage };
217
		String[] taillePage = { "numero_page", "" + pageEncours };
2 aperonnet 218
 
5 aperonnet 219
		criteres2[0] = limite;
220
		criteres2[1] = taillePage;
2726 aurelien 221
 
222
		criteres2[2] = tri;
223
		criteres2[3] = triDir;
5 aperonnet 224
 
225
		for (int i = 0; i < valeursFiltres.length; i++) {
2726 aurelien 226
			criteres2[i + 4] = valeursFiltres[i];
2 aperonnet 227
		}
228
 
5 aperonnet 229
		// et on crée un DAO auquel on les transmet et qui envoie une requete
230
		// pour recevoir les images
2 aperonnet 231
		ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);
5 aperonnet 232
		liaDAO.ObtenirListeImages(this, criteres2);
2 aperonnet 233
	}
5 aperonnet 234
 
2 aperonnet 235
	/**
5 aperonnet 236
	 * Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et
237
	 * lancer l'interface appropriée
2 aperonnet 238
	 */
239
	@SuppressWarnings("static-access")
142 aurelien 240
	public void uploaderImages(boolean multiple) {
5 aperonnet 241
		ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);
142 aurelien 242
		if(multiple) {
243
			IuADaO.appelerUploadMultiple();
244
		}
245
		else
246
		{
247
			IuADaO.appelerUploadSimple();
248
		}
2 aperonnet 249
	}
5 aperonnet 250
 
2 aperonnet 251
	/**
252
	 * Met à jour la liste des images à partir d'un objet
5 aperonnet 253
	 *
254
	 * @param o
255
	 *            la nouvelle liste d'image
2 aperonnet 256
	 */
5 aperonnet 257
	public void rafraichirListeImage(Object o) {
258
		cacheImage = (ListeImageCarnet) o;
2 aperonnet 259
	}
5 aperonnet 260
 
2 aperonnet 261
	/**
262
	 * Met à jour l'arbre des mots clés à partir d'un objet
5 aperonnet 263
	 *
264
	 * @param o
265
	 *            le nouvel arbre de mots clés
2 aperonnet 266
	 */
5 aperonnet 267
	public void rafraichirArbreMotsCles(Object o) {
268
		arbreMotsCles = (com.gwtext.client.data.Tree) o;
2 aperonnet 269
	}
5 aperonnet 270
 
2 aperonnet 271
	/**
5 aperonnet 272
	 * Met à jour la table de correspondance mots clés / ids à partir d'un objet
273
	 *
274
	 * @param o
275
	 *            la nouvelle table des mots clés
2 aperonnet 276
	 */
277
	@SuppressWarnings("unchecked")
5 aperonnet 278
	public void rafraichirMotsCles(Object o) {
279
		if (o instanceof HashMap) {
280
			motsCles = (HashMap<String, String>) o;
2 aperonnet 281
		}
282
	}
5 aperonnet 283
 
2 aperonnet 284
	/**
5 aperonnet 285
	 * Va chercher les métadonnées associées à une image dans la liste des
286
	 * images chargée dans le modèle
287
	 *
288
	 * @param r
289
	 *            le rafraichissable auquel on enverra les informations
290
	 * @param id
291
	 *            l'identifiant de l'image
2 aperonnet 292
	 */
5 aperonnet 293
	public void obtenirMetadonnees(Rafraichissable r, String id) {
1288 aurelien 294
		ImageCarnet im = cacheImage.get(id);
5 aperonnet 295
 
296
		Object meta[] = new Object[3];
297
		meta[0] = im.getMetadonnesExif();
298
		meta[1] = im.getMetadonnesIptc();
299
		meta[2] = im.getInfoGenerales();
300
 
301
		r.rafraichir(meta, false);
2 aperonnet 302
	}
5 aperonnet 303
 
2 aperonnet 304
	/**
5 aperonnet 305
	 * Va chercher les mots clés associés à une image dans la liste des images
306
	 * chargée dans le modèle
307
	 *
308
	 * @param r
309
	 *            le rafraichissable auquel on enverra les informations
310
	 * @param id
311
	 *            l'identifiant de l'image
2 aperonnet 312
	 */
5 aperonnet 313
	public void obtenirMotsClesId(Rafraichissable r, String id) {
314
 
1018 aurelien 315
		String[] motsClesIdTab = getMotsClesId(id);
5 aperonnet 316
		r.rafraichir(motsClesIdTab, false);
2 aperonnet 317
	}
674 aurelien 318
 
1018 aurelien 319
	public String[] getMotsClesId(String idImage) {
320
		ImageCarnet im = cacheImage.get(idImage);
321
		String motsClesId = im.getMotsCles();
322
		String[] motsClesIdTab = motsClesId.split(",");
323
 
324
		return motsClesIdTab;
325
	}
326
 
674 aurelien 327
	/**
328
	 * Va chercher le nom du mot clé associé à un id dans le cache local
329
	 *
330
	 * @param String id
331
	 *            id du mot clé
332
	 * @return le mot clé associé à l'identifiant
333
	 */
334
	public String obtenirTexteMotCle(String id) {
335
 
336
		String correspondanceId = "";
337
 
338
		String motCleTexte = motsCles.get(id);
339
 
340
		if(motCleTexte != null) {
341
			correspondanceId = motCleTexte;
342
		}
343
 
344
		return correspondanceId;
345
	}
1009 aurelien 346
 
347
	/**
348
	 * Construit une chaine contenant le texte des mots clés séparés par des virgules
349
	*/
350
	public String renvoyerChaineMotClesTexte(ImageCarnet ic) {
351
		String chaineMotsCles = ic.getMotsCles();
352
		String[] tabMotsCles = chaineMotsCles.split(",");
353
		String chaineMotsClesTexte = "";
354
		for (int i = 0; i < tabMotsCles.length; i++) {
355
			chaineMotsClesTexte += motsCles.get(tabMotsCles[i]);
356
			chaineMotsClesTexte += (i != tabMotsCles.length - 1) ? "," : "";
357
		}
358
		return chaineMotsClesTexte;
359
	}
5 aperonnet 360
 
2 aperonnet 361
	/**
5 aperonnet 362
	 * Met à jour la liste des images en local et appelle le DAO de mise à jour
363
	 * pour les commentaires et la date des images selectionnées
364
	 *
365
	 * @param commentaires
366
	 *            le commentaire à appliquer
367
	 * @param date
368
	 *            la date à appliquer
369
	 * @param ids
370
	 *            les identifiants des images selectionnées
2 aperonnet 371
	 */
5 aperonnet 372
	public void mettreAJourCacheImage(String commentaires, String date,
373
			String note, String ids[]) {
374
		for (int i = 0; i < ids.length; i++) {
375
			String key = ids[i];
376
			ImageCarnet ic = cacheImage.get(key);
377
			ic.miseAJourInfoGenerales(commentaires, date, note);
378
			mettreAjourBaseDeDonneesImageCarnet(ic);
379
		}
380
 
2 aperonnet 381
	}
5 aperonnet 382
 
2 aperonnet 383
	/**
384
	 * Ajoute un nouveau mot clés à la liste des mots clés locale
5 aperonnet 385
	 *
386
	 * @param text
387
	 *            le mot clé
388
	 * @param id
389
	 *            l'identifiant du mot clé
2 aperonnet 390
	 */
5 aperonnet 391
	public void mettreAjourMotsClesId(String text, String id) {
392
		motsCles.put(id, text);
2 aperonnet 393
	}
5 aperonnet 394
 
2 aperonnet 395
	/**
5 aperonnet 396
	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes
397
	 * les informations des images modifiées par l'utilisateur
2 aperonnet 398
	 */
5 aperonnet 399
	public void mettreAJourBaseDeDonneesListeImageCarnet() {
2 aperonnet 400
		ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);
5 aperonnet 401
 
2 aperonnet 402
		liDaO.SynchroniserBaseDeDonnees(cacheImage);
403
	}
5 aperonnet 404
 
2 aperonnet 405
	/**
5 aperonnet 406
	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes
407
	 * les informations d'une image donnée
408
	 *
409
	 * @param ic
410
	 *            l'image à synchroniser avec la base
2 aperonnet 411
	 */
5 aperonnet 412
	public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) {
2 aperonnet 413
		ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);
5 aperonnet 414
		iaDaO.SynchroniserBaseDeDonnees(ic);
2 aperonnet 415
	}
416
 
417
	/**
5 aperonnet 418
	 * Supprime les images données du cache local et appelle le DAO qui les
419
	 * supprime de la base de données
420
	 *
421
	 * @param ids
422
	 *            les identifiants des images selectionnées
2 aperonnet 423
	 */
5 aperonnet 424
	public void supprimerImages(String[] ids) {
425
		String rids[] = new String[ids.length];
426
		ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);
427
 
428
		for (int i = 0; i < ids.length; i++) {
429
			String key = ids[i];
430
			ImageCarnet ic = cacheImage.get(key);
431
			rids[i] = ic.getId();
432
 
433
			cacheImage.remove(key);
2 aperonnet 434
		}
5 aperonnet 435
 
436
		if (rids.length != 0) {
2 aperonnet 437
			liDao.supprimerBaseDeDonnees(rids);
5 aperonnet 438
		}
2 aperonnet 439
	}
440
 
441
	/**
5 aperonnet 442
	 * Met à jour les données locales suivant le type des nouvelles données et
443
	 * appelle le médiateur pour le notifier de la mise à jour
2 aperonnet 444
	 */
1288 aurelien 445
	@Override
5 aperonnet 446
	public void rafraichir(Object nouvelleDonnees,
447
			boolean repandreRafraichissement) {
2 aperonnet 448
		// si l'on a reçu une liste d'images
5 aperonnet 449
		if (nouvelleDonnees instanceof ListeImageCarnet) {
450
			ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees;
2726 aurelien 451
			Object[][] photoData = new Object[data.size()][14];
5 aperonnet 452
			int i = 0;
2 aperonnet 453
 
5 aperonnet 454
			if (data.size() == 0) {
455
				pageEncours = 0;
456
			}
457
 
598 aurelien 458
			// on la parse et on récupère les informations qui nous interessent
5 aperonnet 459
			for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {
460
				ImageCarnet im = data.get(it.next());
461
				photoData[i][0] = im.getOrdre();
212 aurelien 462
				photoData[i][1] = im.getNomOriginal();
463
				photoData[i][2] = im.getDate();
464
				photoData[i][3] = im.getIptcCity();
989 aurelien 465
				photoData[i][4] = im.getFabriquantAppareil() + " " + im.getModeleAppareil();
659 aurelien 466
				photoData[i][5] = im.getUrlFormatListe();
467
				photoData[i][6] = im.getUrlFormatGalerie();
468
				photoData[i][7] = im.getUrlFormatZoom();
212 aurelien 469
				photoData[i][8] = im.getNote();
470
				photoData[i][9] = im.getId();
471
				photoData[i][10] = im.getTailleImage()[1];
472
				photoData[i][11] = im.getTailleImage()[0];
400 aurelien 473
				photoData[i][12] = im.getIdsObsAssociees();
2726 aurelien 474
				photoData[i][13] = im.getIdsObsAssociees();
5 aperonnet 475
 
476
				i++;
477
			}
478
 
479
 
2726 aurelien 480
			RecordDef rd = new RecordDef(ImageMediateur.getDefinitionsChampsGrilleImages());
481
 
5 aperonnet 482
			final MemoryProxy dataProxy = new MemoryProxy(photoData);
483
			final ArrayReader reader = new ArrayReader(rd);
484
 
485
			final Store photoStore = new Store(dataProxy, reader);
486
 
487
			rafraichirListeImage(nouvelleDonnees);
488
 
489
			st = photoStore;
490
			st.load();
491
 
492
			// si on doit répandre les données, on notifie le médiateur qui les
493
			// distribuera à son tour
494
			if (repandreRafraichissement) {
495
				getIMediateur().synchroniserDonneesZoomListeGalerie(st, this);
496
			}
2 aperonnet 497
		}
5 aperonnet 498
 
2 aperonnet 499
		// si on reçoit un tableau JSON
5 aperonnet 500
		if (nouvelleDonnees instanceof JSONArray) {
2042 aurelien 501
			// alors on a reçu les informations sur les mots clés
502
			JSONArray donneesArbre = (JSONArray)nouvelleDonnees;
674 aurelien 503
 
2062 aurelien 504
			Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre("Tags", "racine", donneesArbre, false);
2042 aurelien 505
 
506
			arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
507
			motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
5 aperonnet 508
 
509
			// enfin on met à jour l'arbre des mots clés contenu dans le modèle
510
			rafraichirArbreMotsCles(arbreMotsCles);
674 aurelien 511
			// la table de hachage
512
			rafraichirMotsCles(motsCles);
5 aperonnet 513
			// et on notifie le médiateur de la mise à jour en lui passant une
514
			// copie des données
515
			getIMediateur().rafraichirArbreMotsCles(arbreMotsCles);
2 aperonnet 516
		}
5 aperonnet 517
 
2 aperonnet 518
		// Si on reçoit un tableau d'entiers
5 aperonnet 519
		// c'est un tableau d'un seul entier qui est le nombre d'images
520
		// correspondant aux critères
521
		if (nouvelleDonnees instanceof int[]) {
522
			int[] pages = (int[]) nouvelleDonnees;
523
 
524
			// on calcule le nombre de pages nécessaires et on les met à jour
525
			// dans le modèle
526
			pageMax = calculerNbPages(pages[0]);
527
			nbElements = pages[0];
528
 
529
			// et on notifie de le mediateur du changement des valeurs
530
			getIMediateur().changerPageMaxEtCourante(pageMax, pageEncours,
531
					taillePage, pages[0]);
2 aperonnet 532
 
5 aperonnet 533
			obtenirPhotoGalerie(this) ;
2 aperonnet 534
		}
99 jpm 535
 
536
		if(nouvelleDonnees instanceof ListeObservation) {
537
 
158 aurelien 538
			getIMediateur().rafraichirMiniListeObservations((ListeObservation)nouvelleDonnees) ;
99 jpm 539
		}
158 aurelien 540
 
541
		if(nouvelleDonnees instanceof Tree) {
542
			rafraichirArbreMotsCles(nouvelleDonnees);
543
			getIMediateur().rafraichirArbreMotsCles((Tree)nouvelleDonnees);
544
		}
2 aperonnet 545
	}
5 aperonnet 546
 
2 aperonnet 547
	/**
5 aperonnet 548
	 * Met à jour les mots clés associés à une image et appelle le DAO pour
549
	 * synchroniser la base de données
550
	 *
551
	 * @param ids
552
	 *            les identifiants des images selectionnées
553
	 * @param motsClesEnCours
554
	 *            les mots clés à appliquer aux images
555
	 * @param arbreMC
556
	 *            l'arbre de mots clés en cours
2 aperonnet 557
	 */
5 aperonnet 558
	public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,
559
			com.gwtext.client.data.Tree arbreMC) {
971 aurelien 560
 
561
		String idImgs = "";
5 aperonnet 562
		for (int i = 0; i < ids.length; i++) {
1316 aurelien 563
			String idImageEnCours = "";
5 aperonnet 564
			if (cacheImage.containsKey(ids[i])) {
1288 aurelien 565
				ImageCarnet ic = cacheImage.get(ids[i]);
1316 aurelien 566
				idImageEnCours = ic.getId();
5 aperonnet 567
				ic.mettreAjourMotsCles(motsClesEnCours);
2 aperonnet 568
			}
1316 aurelien 569
			idImgs += idImageEnCours;
971 aurelien 570
			idImgs += (i < (ids.length - 1)) ? ",": "";
2 aperonnet 571
		}
971 aurelien 572
 
573
		LiaisonMotsClesImageAsynchroneDAO liMcDao = new LiaisonMotsClesImageAsynchroneDAO(this);
574
		liMcDao.modifier(this, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idImgs, motsClesEnCours);
5 aperonnet 575
 
576
		rafraichirArbreMotsCles(arbreMC);
2 aperonnet 577
	}
5 aperonnet 578
 
2 aperonnet 579
	/**
5 aperonnet 580
	 * Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la
581
	 * base de données
2 aperonnet 582
	 */
5 aperonnet 583
	public void initialiserArbreMotsCles() {
137 aurelien 584
 
1018 aurelien 585
			MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
137 aurelien 586
			MCDao.obtenirListeMotsCles(this);
2 aperonnet 587
	}
5 aperonnet 588
 
2 aperonnet 589
	/**
5 aperonnet 590
	 * Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable
591
	 * donné, qui le demande
592
	 *
593
	 * @param r
594
	 *            le rafraichissable demandeur de l'arbre
2 aperonnet 595
	 */
5 aperonnet 596
	public void obtenirArbreMotCle(Rafraichissable r) {
137 aurelien 597
			r.rafraichir(arbreMotsCles, false);
2 aperonnet 598
	}
599
 
600
	/**
5 aperonnet 601
	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
602
	 * fait la mise à jour de l'arbre des mots clés dans la base
603
	 *
604
	 * @param n
605
	 *            le nouveau noeud contenant le mot clé
606
	 * @param arbreMC
607
	 *            l'arbre des mots cles en cours
2 aperonnet 608
	 */
5 aperonnet 609
	public void ajouterMotCleDansArbre(TreeNode n,
2042 aurelien 610
			com.gwtext.client.data.Tree arbreMC, Rafraichissable r) {
1018 aurelien 611
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
5 aperonnet 612
 
613
		String[] usObj = (String[]) n.getUserObject();
614
		String motCle = usObj[0];
615
		String id = usObj[1];
616
		String parentId = "";
617
 
618
		if (!id.equals("racine")) {
619
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
2062 aurelien 620
			if(!parentUsObj[1].equals("racine")) {
621
				parentId = parentUsObj[1];
622
			}
2 aperonnet 623
		}
5 aperonnet 624
 
625
		rafraichirArbreMotsCles(arbreMC);
1018 aurelien 626
		mettreAjourMotsClesId(motCle, id);
5 aperonnet 627
 
628
		String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
629
				+ motCle + "&id=" + id + "&parent=" + parentId;
2042 aurelien 630
		MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
2 aperonnet 631
	}
632
 
633
	/**
5 aperonnet 634
	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
635
	 * supprimer les mots clés associés dans la base
636
	 *
637
	 * @param n
638
	 *            le noeud à supprimer
639
	 * @param arbreMC
640
	 *            l'arbre des mots clés en cours
2 aperonnet 641
	 */
2062 aurelien 642
	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
5 aperonnet 643
 
1018 aurelien 644
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
5 aperonnet 645
 
646
		String[] usObj = (String[]) n.getUserObject();
647
		String id = usObj[1];
648
 
2062 aurelien 649
		MCDao.supprimerBaseDeDonnees(id, r);
5 aperonnet 650
 
2 aperonnet 651
	}
652
 
653
	/**
5 aperonnet 654
	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
655
	 * DAO qui synchronise la modification dans la base de données
656
	 *
657
	 * @param n
658
	 *            le noeud modifié
659
	 * @param arbreMC
660
	 *            l'arbre des mots clés en cours
2 aperonnet 661
	 */
2042 aurelien 662
	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
5 aperonnet 663
 
1018 aurelien 664
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
5 aperonnet 665
 
666
		String[] usObj = (String[]) n.getUserObject();
667
		String motCle = usObj[0];
668
		String id = usObj[1];
669
		String parentId = "";
670
 
671
		if (!id.equals("racine")) {
672
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
2062 aurelien 673
			if(!parentUsObj[1].equals("racine")) {
674
				parentId = parentUsObj[1];
675
			}
2 aperonnet 676
		}
5 aperonnet 677
 
678
		rafraichirArbreMotsCles(arbreMC);
679
 
680
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
681
				+ parentId;
2042 aurelien 682
		MCDao.modifierBaseDeDonnees(motCleModifie, r);
5 aperonnet 683
 
2 aperonnet 684
	}
5 aperonnet 685
 
2 aperonnet 686
	/**
5 aperonnet 687
	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
688
	 * reorganise l'arbre dans la base de donnees suivant le changement
689
	 *
690
	 * @param n
691
	 *            le noeud deplace (et son sous arbre associe)
692
	 * @param arbreMC
693
	 *            l'arbre des mots cles en cours
2 aperonnet 694
	 */
2042 aurelien 695
	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
1018 aurelien 696
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
5 aperonnet 697
 
698
		String[] usObj = (String[]) n.getUserObject();
699
		String motCle = usObj[0];
700
		String id = usObj[1];
701
		String parentId = "";
2062 aurelien 702
 
5 aperonnet 703
		if (!id.equals("racine")) {
704
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
2062 aurelien 705
			if(!parentUsObj[1].equals("racine")) {
706
				parentId = parentUsObj[1];
707
			}
2 aperonnet 708
		}
5 aperonnet 709
 
710
		rafraichirArbreMotsCles(arbreMC);
711
 
712
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
713
				+ parentId;
2042 aurelien 714
		MCDao.deplacerBaseDeDonnees(motCleModifie, r);
2 aperonnet 715
	}
5 aperonnet 716
 
2 aperonnet 717
	/**
5 aperonnet 718
	 * Change le numéro de la page en cours et envoie une demande de mise à jour
719
	 * des données
720
	 *
721
	 * @param nouvellePageCourante
722
	 *            la nouvelle page à afficher
2 aperonnet 723
	 */
5 aperonnet 724
	public void changerNumeroPage(int nouvellePageCourante) {
725
		pageEncours = nouvellePageCourante;
726
		obtenirNombrePhotoGalerie(this);
2 aperonnet 727
	}
5 aperonnet 728
 
2 aperonnet 729
	/**
5 aperonnet 730
	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements
731
	 * donnés en fonction de la taille de page en cours
732
	 *
733
	 * @param nbElements
734
	 *            le nombre d'élements total
735
	 * @return le nombre de pages
2 aperonnet 736
	 */
5 aperonnet 737
	public int calculerNbPages(int nbElements) {
738
		// A cause de la betise de java pour les conversion implicite on fait
739
		// quelques conversions manuellement
2 aperonnet 740
		// pour eviter qu'il arrondisse mal la division
5 aperonnet 741
		// nombre de pages = (nombre d'element / taille de la page) arrondie à
742
		// l'entier superieur
743
		double nPage = (1.0 * nbElements) / (1.0 * taillePage);
744
		double nPageRound = Math.ceil(nPage);
745
		Double nPageInt = new Double(nPageRound);
746
 
2 aperonnet 747
		// on convertit en entier
5 aperonnet 748
		return nPageInt.intValue();
2 aperonnet 749
	}
5 aperonnet 750
 
2 aperonnet 751
	/**
752
	 * Recalcule la page en cours lors du changement du nombre d'élements
5 aperonnet 753
	 *
754
	 * @param nbElements
755
	 *            le nombre d'élements total
2 aperonnet 756
	 * @return la nouvelle page encours
757
	 */
5 aperonnet 758
	public int calculerPageCourante(int nbElements) {
2 aperonnet 759
		// on calcule le nombre de page
5 aperonnet 760
		int nouvelNbPages = calculerNbPages(nbElements);
2 aperonnet 761
		// la nouvelle page en cours
5 aperonnet 762
		double nPageCourante = (1.0 * pageEncours) / (1.0 * pageMax)
763
				* (1.0 * nouvelNbPages);
764
 
2 aperonnet 765
		// on arrondit au supérieur
5 aperonnet 766
		double nPageRound = Math.ceil(nPageCourante);
767
		Double nPageInt = new Double(nPageRound);
768
 
2 aperonnet 769
		// on convertit en entier
5 aperonnet 770
		return Math.abs(nPageInt.intValue());
2 aperonnet 771
	}
5 aperonnet 772
 
2 aperonnet 773
	/**
5 aperonnet 774
	 * Change la taille de page et recalcule la page encours
775
	 *
776
	 * @param nouvelleTaillePage
777
	 *            la nouvelle taille de page à utiliser
2 aperonnet 778
	 */
5 aperonnet 779
	public void changerTaillePage(int nouvelleTaillePage) {
780
		taillePage = nouvelleTaillePage;
781
		pageEncours = calculerPageCourante(nbElements);
782
		obtenirNombrePhotoGalerie(this);
2 aperonnet 783
	}
690 aurelien 784
 
785
	/**
786
	 * Met la valeur de la page en cours à la dernière
787
	 */
788
	public void setDernierePage() {
789
		changerNumeroPage(pageMax);
790
	}
5 aperonnet 791
 
2 aperonnet 792
	/**
5 aperonnet 793
	 * Notifie le mediateur que l'upload ou le download est termine et qu'il
794
	 * faut rafraichir les vues avec les nouvelles données
2 aperonnet 795
	 */
5 aperonnet 796
	public void requeteTerminee() {
797
		getIMediateur().demasquerChargement();
798
		getIMediateur().rafraichirToutesVues();
2 aperonnet 799
	}
800
 
801
	/**
802
	 * Obtient l'identifiant de l'utilisateur auprès du médiateur
5 aperonnet 803
	 *
2 aperonnet 804
	 * @return id de l'utilisateur
805
	 */
806
	public String getIdentifiant() {
5 aperonnet 807
 
808
		return getIMediateur().getIdentifiant();
2 aperonnet 809
	}
810
 
811
	/**
812
	 * renvoie la taille d'une image grâce à son identifiant
5 aperonnet 813
	 *
814
	 * @param id
815
	 *            l'identifiant de l'image
2 aperonnet 816
	 * @return un tableau contenant la longueur et la hauteur de l'image
817
	 */
818
	public String[] obtenirTailleImage(String id) {
5 aperonnet 819
 
820
		return (cacheImage.get(id)).getTailleImage();
821
 
2 aperonnet 822
	}
823
 
824
	/**
5 aperonnet 825
	 * Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il
2 aperonnet 826
	 * renvoie la note associée au rafrachissable qui la demande
5 aperonnet 827
	 *
828
	 * @param r
829
	 *            le rafraichissable demandeur de l'information
830
	 * @param id
831
	 *            l'identifiant del'image
2 aperonnet 832
	 */
833
	public void obtenirNote(Rafraichissable r, String id) {
5 aperonnet 834
 
835
		r.rafraichir((cacheImage.get(id)).getNote(), true);
836
 
2 aperonnet 837
	}
5 aperonnet 838
 
2 aperonnet 839
	/**
840
	 * Accesseur pour la configuration en cours d'utilisation
5 aperonnet 841
	 *
2 aperonnet 842
	 * @return la configuration
843
	 */
844
	public Configuration getConfig() {
5 aperonnet 845
 
846
		return config;
847
	}
848
 
849
	/**
850
	 * Ajoute des images à la selection en cours
851
	 *
852
	 * @param ids
853
	 *            les identifiants des images à ajouter
854
	 */
855
	public void ajouterImagesSelection(String[] ids) {
856
 
857
		for (int i = 0; i < ids.length; i++) {
142 aurelien 858
 
859
			String idImg = cacheImage.get(ids[i]).getId();
860
			selectionImages.add(idImg);
5 aperonnet 861
		}
862
	}
863
 
173 aurelien 864
	public int getCompteSelection() {
865
		return selectionImages.size();
866
	}
867
 
5 aperonnet 868
	/**
869
	 * Vide la selection en cours
870
	 */
871
	public void viderSelection() {
872
		selectionImages.clear();
873
	}
874
 
875
	public String renvoyerSelection() {
876
 
877
		String selection = "";
2 aperonnet 878
 
5 aperonnet 879
		if(selectionImages.size() <= 0)
880
		{
881
			selection += "-255" ;
882
		}
883
		else
884
		{
885
			for (Iterator<String> it = selectionImages.iterator(); it.hasNext();) {
886
 
887
				String idEncours = it.next();
888
				selection += idEncours + ",";
889
			}
890
		}
891
 
892
		return selection;
2 aperonnet 893
	}
5 aperonnet 894
 
895
	public void lierImagesObervations(String idsObs, String idsImg) {
896
 
897
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
898
		lienDAO.lierImageBaseDeDonnees(idsImg, idsObs) ;
899
 
900
	}
901
 
81 jpm 902
	public void obtenirLiaisonObservations(ImageMediateur imageMediateur,
903
			String id) {
904
 
905
		String imgId = cacheImage.get(id).getId() ;
906
 
907
		LienImageAsynchroneDAO lienDao = new LienImageAsynchroneDAO(this) ;
908
		lienDao.obtenirLiaisonsImagesObservations(this, imgId) ;
909
 
910
	}
911
 
598 aurelien 912
	public void supprimerLiaisonImages(String[] idsImg, String idObs) {
104 jpm 913
 
598 aurelien 914
		String chaineIdImg = "";
104 jpm 915
 
598 aurelien 916
		for(int i = 0; i < idsImg.length; i++) {
917
			String idImg = cacheImage.get(idsImg[i]).getId() ;
918
			chaineIdImg += ","+idImg;
919
		}
920
 
921
		chaineIdImg = chaineIdImg.replaceFirst(",", "");
922
 
104 jpm 923
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
598 aurelien 924
		lienDAO.supprimerLienImageObservation(chaineIdImg, idObs) ;
104 jpm 925
	}
926
 
413 aurelien 927
	public void obtenirMiniListeObservations(Rafraichissable r, String[] critere, int taillePage, int numeroPage) {
928
 
2726 aurelien 929
		String[] tri = { "tri", "" + getIMediateur().getTriMiniListeObs() };
930
		String[] triDir = { "tri_dir", "" + getIMediateur().getDirectionTriMiniListeObs()};
413 aurelien 931
 
2726 aurelien 932
		String[][] criteres = {{critere[0],critere[1]},{"limite",""+taillePage},{"numero_page",""+numeroPage}, tri, triDir} ;
933
 
413 aurelien 934
		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
935
		ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
936
		loaDAO.obtenirListeObservation(r, iMediateur.getIdentifiant(), criteres);
937
 
938
	}
939
 
940
	public void obtenirNombreMiniListeObservations(Rafraichissable r, String[] critere) {
941
 
942
		String[][] criteres = {{critere[0],critere[1]}} ;
943
 
944
		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
945
		NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this);
946
		noaDAO.obtenirNombreObservation(r, iMediateur.getIdentifiant(), criteres);
947
 
948
	}
949
 
659 aurelien 950
	public void obtenirDatesImages(Rafraichissable r) {
951
		ListeDateImageAsynchroneDAO lDateDao = new ListeDateImageAsynchroneDAO(this);
952
		lDateDao.obtenirListeDate(r, iMediateur.getIdentifiant());
953
	}
1832 aurelien 954
 
955
	public String obtenirIdPourOrdre(String ordreImage) {
956
		return cacheImage.get(ordreImage).getId();
957
	}
659 aurelien 958
 
2 aperonnet 959
}