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