Subversion Repositories eFlore/Applications.cel

Rev

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