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