Subversion Repositories eFlore/Applications.cel

Rev

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