Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 aperonnet 1
package org.tela_botanica.client.image;
2
 
3
import java.util.HashMap;
4
import java.util.Iterator;
5 aperonnet 5
import java.util.Vector;
2 aperonnet 6
 
7
import org.tela_botanica.client.interfaces.Rafraichissable;
8
import org.tela_botanica.client.modeles.Configuration;
9
import org.tela_botanica.client.modeles.ImageAsynchroneDAO;
10
import org.tela_botanica.client.modeles.ImageCarnet;
11
import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;
5 aperonnet 12
import org.tela_botanica.client.modeles.LienImageAsynchroneDAO;
2 aperonnet 13
import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;
14
import org.tela_botanica.client.modeles.ListeImageCarnet;
99 jpm 15
import org.tela_botanica.client.modeles.ListeObservation;
2 aperonnet 16
import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;
17
import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;
18
 
19
import com.google.gwt.json.client.JSONArray;
20
import com.google.gwt.json.client.JSONObject;
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")
5 aperonnet 202
	public void uploaderImages() {
203
		ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);
204
		IuADaO.choisirMethodeUpload();
2 aperonnet 205
	}
5 aperonnet 206
 
2 aperonnet 207
	/**
208
	 * Met à jour la liste des images à partir d'un objet
5 aperonnet 209
	 *
210
	 * @param o
211
	 *            la nouvelle liste d'image
2 aperonnet 212
	 */
5 aperonnet 213
	public void rafraichirListeImage(Object o) {
214
		cacheImage = (ListeImageCarnet) o;
2 aperonnet 215
	}
5 aperonnet 216
 
2 aperonnet 217
	/**
218
	 * Met à jour l'arbre des mots clés à partir d'un objet
5 aperonnet 219
	 *
220
	 * @param o
221
	 *            le nouvel arbre de mots clés
2 aperonnet 222
	 */
5 aperonnet 223
	public void rafraichirArbreMotsCles(Object o) {
224
		arbreMotsCles = (com.gwtext.client.data.Tree) o;
2 aperonnet 225
	}
5 aperonnet 226
 
2 aperonnet 227
	/**
5 aperonnet 228
	 * Met à jour la table de correspondance mots clés / ids à partir d'un objet
229
	 *
230
	 * @param o
231
	 *            la nouvelle table des mots clés
2 aperonnet 232
	 */
233
	@SuppressWarnings("unchecked")
5 aperonnet 234
	public void rafraichirMotsCles(Object o) {
235
		if (o instanceof HashMap) {
236
			motsCles = (HashMap<String, String>) o;
2 aperonnet 237
		}
238
	}
5 aperonnet 239
 
2 aperonnet 240
	/**
5 aperonnet 241
	 * Va chercher les métadonnées associées à une image dans la liste des
242
	 * images chargée dans le modèle
243
	 *
244
	 * @param r
245
	 *            le rafraichissable auquel on enverra les informations
246
	 * @param id
247
	 *            l'identifiant de l'image
2 aperonnet 248
	 */
5 aperonnet 249
	public void obtenirMetadonnees(Rafraichissable r, String id) {
250
		ImageCarnet im = (ImageCarnet) cacheImage.get(id);
251
 
252
		Object meta[] = new Object[3];
253
		meta[0] = im.getMetadonnesExif();
254
		meta[1] = im.getMetadonnesIptc();
255
		meta[2] = im.getInfoGenerales();
256
 
257
		r.rafraichir(meta, false);
2 aperonnet 258
	}
5 aperonnet 259
 
2 aperonnet 260
	/**
5 aperonnet 261
	 * Va chercher les mots clés associés à une image dans la liste des images
262
	 * chargée dans le modèle
263
	 *
264
	 * @param r
265
	 *            le rafraichissable auquel on enverra les informations
266
	 * @param id
267
	 *            l'identifiant de l'image
2 aperonnet 268
	 */
5 aperonnet 269
	public void obtenirMotsClesId(Rafraichissable r, String id) {
270
		ImageCarnet im = cacheImage.get(id);
271
		String motsClesId = im.getMotsCles();
272
		String[] motsClesIdTab = motsClesId.split(",");
273
 
274
		r.rafraichir(motsClesIdTab, false);
2 aperonnet 275
	}
5 aperonnet 276
 
2 aperonnet 277
	/**
5 aperonnet 278
	 * Met à jour la liste des images en local et appelle le DAO de mise à jour
279
	 * pour les commentaires et la date des images selectionnées
280
	 *
281
	 * @param commentaires
282
	 *            le commentaire à appliquer
283
	 * @param date
284
	 *            la date à appliquer
285
	 * @param ids
286
	 *            les identifiants des images selectionnées
2 aperonnet 287
	 */
5 aperonnet 288
	public void mettreAJourCacheImage(String commentaires, String date,
289
			String note, String ids[]) {
290
		for (int i = 0; i < ids.length; i++) {
291
			String key = ids[i];
292
			ImageCarnet ic = cacheImage.get(key);
293
			ic.miseAJourInfoGenerales(commentaires, date, note);
294
			mettreAjourBaseDeDonneesImageCarnet(ic);
295
		}
296
 
2 aperonnet 297
	}
5 aperonnet 298
 
2 aperonnet 299
	/**
300
	 * Ajoute un nouveau mot clés à la liste des mots clés locale
5 aperonnet 301
	 *
302
	 * @param text
303
	 *            le mot clé
304
	 * @param id
305
	 *            l'identifiant du mot clé
2 aperonnet 306
	 */
5 aperonnet 307
	public void mettreAjourMotsClesId(String text, String id) {
308
		motsCles.put(id, text);
2 aperonnet 309
	}
5 aperonnet 310
 
2 aperonnet 311
	/**
5 aperonnet 312
	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes
313
	 * les informations des images modifiées par l'utilisateur
2 aperonnet 314
	 */
5 aperonnet 315
	public void mettreAJourBaseDeDonneesListeImageCarnet() {
2 aperonnet 316
		ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);
5 aperonnet 317
 
2 aperonnet 318
		liDaO.SynchroniserBaseDeDonnees(cacheImage);
319
	}
5 aperonnet 320
 
2 aperonnet 321
	/**
5 aperonnet 322
	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes
323
	 * les informations d'une image donnée
324
	 *
325
	 * @param ic
326
	 *            l'image à synchroniser avec la base
2 aperonnet 327
	 */
5 aperonnet 328
	public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) {
2 aperonnet 329
		ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);
5 aperonnet 330
		iaDaO.SynchroniserBaseDeDonnees(ic);
2 aperonnet 331
	}
332
 
333
	/**
5 aperonnet 334
	 * Supprime les images données du cache local et appelle le DAO qui les
335
	 * supprime de la base de données
336
	 *
337
	 * @param ids
338
	 *            les identifiants des images selectionnées
2 aperonnet 339
	 */
5 aperonnet 340
	public void supprimerImages(String[] ids) {
341
		String rids[] = new String[ids.length];
342
		ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);
343
 
344
		for (int i = 0; i < ids.length; i++) {
345
			String key = ids[i];
346
			ImageCarnet ic = cacheImage.get(key);
347
			rids[i] = ic.getId();
348
 
349
			cacheImage.remove(key);
2 aperonnet 350
		}
5 aperonnet 351
 
352
		if (rids.length != 0) {
2 aperonnet 353
			liDao.supprimerBaseDeDonnees(rids);
5 aperonnet 354
		}
2 aperonnet 355
	}
356
 
357
	/**
5 aperonnet 358
	 * Met à jour les données locales suivant le type des nouvelles données et
359
	 * appelle le médiateur pour le notifier de la mise à jour
2 aperonnet 360
	 */
5 aperonnet 361
	public void rafraichir(Object nouvelleDonnees,
362
			boolean repandreRafraichissement) {
2 aperonnet 363
		// si l'on a reçu une liste d'images
5 aperonnet 364
		if (nouvelleDonnees instanceof ListeImageCarnet) {
365
			ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees;
366
			Object[][] photoData = new Object[data.size()][9];
367
			int i = 0;
2 aperonnet 368
 
5 aperonnet 369
			if (data.size() == 0) {
370
				pageEncours = 0;
371
			}
372
 
373
			// on la parse et on récupère les informations quiç nous interessent
374
			for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {
375
				ImageCarnet im = data.get(it.next());
376
				photoData[i][0] = im.getOrdre();
377
				photoData[i][1] = im.getDate();
378
				photoData[i][2] = im.getIptcCity();
379
				photoData[i][3] = im.getMake() + " " + im.getModel();
380
				photoData[i][4] = im.getSUrl();
381
				photoData[i][5] = im.getMUrl();
382
				photoData[i][6] = im.getLUrl();
383
				photoData[i][7] = im.getNote();
384
				photoData[i][8] = im.getId();
385
 
386
				i++;
387
			}
388
 
389
			// creation du store qui les contient
390
			FieldDef defNumImage = new IntegerFieldDef("num_image");
391
			FieldDef defDatImage = new StringFieldDef("dat_image");
392
			FieldDef defLieImage = new StringFieldDef("lie_image");
393
			FieldDef defAppImage = new StringFieldDef("app_image");
394
			FieldDef defUrlImageS = new StringFieldDef("url_image_S");
395
			FieldDef defUrlImageM = new StringFieldDef("url_image_M");
396
			FieldDef defUrlImage = new StringFieldDef("url_image");
397
			FieldDef defNoteImage = new IntegerFieldDef("note_image");
398
			FieldDef defIdImage = new IntegerFieldDef("id_image");
399
			FieldDef[] defTab = { defNumImage, defDatImage, defLieImage,
400
					defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
401
					defNoteImage, defIdImage };
402
			RecordDef rd = new RecordDef(defTab);
403
 
404
			final MemoryProxy dataProxy = new MemoryProxy(photoData);
405
			final ArrayReader reader = new ArrayReader(rd);
406
 
407
			final Store photoStore = new Store(dataProxy, reader);
408
 
409
			rafraichirListeImage(nouvelleDonnees);
410
 
411
			st = photoStore;
412
			st.load();
413
 
414
			// par défaut le store est trié sur le numéro d'image
415
			st.sort("num_image");
416
 
417
			// si on doit répandre les données, on notifie le médiateur qui les
418
			// distribuera à son tour
419
			if (repandreRafraichissement) {
420
				getIMediateur().synchroniserDonneesZoomListeGalerie(st, this);
421
			}
2 aperonnet 422
		}
5 aperonnet 423
 
2 aperonnet 424
		// si on reçoit un tableau JSON
5 aperonnet 425
		if (nouvelleDonnees instanceof JSONArray) {
2 aperonnet 426
			// alors on a reçu les informations sur les mots clés
5 aperonnet 427
			JSONArray reponse = (JSONArray) nouvelleDonnees;
428
 
2 aperonnet 429
			final int taillemax = reponse.size();
5 aperonnet 430
 
2 aperonnet 431
			// si le tableau est vide
5 aperonnet 432
			if (taillemax == 0) {
2 aperonnet 433
				// on crée un arbre vide
5 aperonnet 434
				TreeNode root = new TreeNode();
435
				root.setId("racine");
436
				root.setText("Tags");
437
				String[] usObj = { "Tags", "racine" };
438
				root.setUserObject(usObj);
439
				arbreMotsCles.setRootNode(root);
2 aperonnet 440
			}
5 aperonnet 441
 
2 aperonnet 442
			// pour chacun des élements du tableau
5 aperonnet 443
			for (int j = 0; j < taillemax; j++) {
2 aperonnet 444
				// on extrait les élements du tableau
5 aperonnet 445
				if (reponse.get(j).isObject() != null) {
446
					JSONObject noeud = (JSONObject) reponse.get(j);
447
 
448
					String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur")
449
							.isString().stringValue();
450
					String mot_cle = noeud.get("cmc_mot_cle").isString()
451
							.stringValue();
452
					String parent = noeud.get("cmc_id_parent").isString()
453
							.stringValue();
454
 
455
					String[] usObj = { mot_cle, id_noeud };
456
 
457
					// et on construit l'arbre à partir de la racine (qui est
458
					// toujoursl e premier élément)
459
					if (id_noeud.equals("racine")) {
460
						TreeNode root = new TreeNode();
461
						root.setId(id_noeud);
462
						root.setText(mot_cle);
463
						root.setUserObject(usObj);
464
						arbreMotsCles.setRootNode(root);
465
					} else {
466
						// et en ajoutant les noeuds un à un (qui sont renvoyé
467
						// dans l'ordre hierarchique de leur niveau
2 aperonnet 468
						// ce qui permet de les traiter séquentiellement)
5 aperonnet 469
						TreeNode node = new TreeNode();
470
						node.setId(id_noeud);
471
						node.setText(mot_cle);
472
						node.setChecked(false);
473
						Node parentNode = arbreMotsCles.getNodeById(parent);
474
						node.setUserObject(usObj);
475
						parentNode.appendChild(node);
2 aperonnet 476
					}
477
				}
5 aperonnet 478
			}
479
			// enfin on met à jour l'arbre des mots clés contenu dans le modèle
480
			rafraichirArbreMotsCles(arbreMotsCles);
481
			// et on notifie le médiateur de la mise à jour en lui passant une
482
			// copie des données
483
			getIMediateur().rafraichirArbreMotsCles(arbreMotsCles);
2 aperonnet 484
		}
5 aperonnet 485
 
2 aperonnet 486
		// Si on reçoit un tableau d'entiers
5 aperonnet 487
		// c'est un tableau d'un seul entier qui est le nombre d'images
488
		// correspondant aux critères
489
		if (nouvelleDonnees instanceof int[]) {
490
			int[] pages = (int[]) nouvelleDonnees;
491
 
492
			// on calcule le nombre de pages nécessaires et on les met à jour
493
			// dans le modèle
494
			pageMax = calculerNbPages(pages[0]);
495
			nbElements = pages[0];
496
 
497
			// et on notifie de le mediateur du changement des valeurs
498
			getIMediateur().changerPageMaxEtCourante(pageMax, pageEncours,
499
					taillePage, pages[0]);
2 aperonnet 500
 
5 aperonnet 501
			obtenirPhotoGalerie(this) ;
2 aperonnet 502
		}
99 jpm 503
 
504
		if(nouvelleDonnees instanceof ListeObservation) {
505
 
506
			getIMediateur().rafraichirMiniListeObservations(nouvelleDonnees) ;
507
		}
2 aperonnet 508
	}
5 aperonnet 509
 
2 aperonnet 510
	/**
511
	 * Affiche les paires / valeur de tous les mots clés stockés
512
	 */
5 aperonnet 513
	public void afficherMotsCles() {
514
		for (Iterator<String> it = motsCles.keySet().iterator(); it.hasNext();) {
515
			String key = it.next();
516
			String valeur = (String) motsCles.get(key);
517
			System.out.println("clé : " + key + " valeur : " + valeur);
2 aperonnet 518
		}
519
	}
520
 
521
	/**
5 aperonnet 522
	 * Met à jour les mots clés associés à une image et appelle le DAO pour
523
	 * synchroniser la base de données
524
	 *
525
	 * @param ids
526
	 *            les identifiants des images selectionnées
527
	 * @param motsClesEnCours
528
	 *            les mots clés à appliquer aux images
529
	 * @param arbreMC
530
	 *            l'arbre de mots clés en cours
2 aperonnet 531
	 */
5 aperonnet 532
	public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,
533
			com.gwtext.client.data.Tree arbreMC) {
534
		for (int i = 0; i < ids.length; i++) {
535
			if (cacheImage.containsKey(ids[i])) {
536
				ImageCarnet ic = (ImageCarnet) cacheImage.get(ids[i]);
537
				ic.mettreAjourMotsCles(motsClesEnCours);
538
 
539
				ImageAsynchroneDAO imgDao = new ImageAsynchroneDAO(this);
540
				imgDao.SynchroniserMotsClesImageBaseDeDonnees(ic);
2 aperonnet 541
			}
542
		}
5 aperonnet 543
 
544
		rafraichirArbreMotsCles(arbreMC);
2 aperonnet 545
	}
5 aperonnet 546
 
2 aperonnet 547
	/**
5 aperonnet 548
	 * Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la
549
	 * base de données
2 aperonnet 550
	 */
5 aperonnet 551
	public void initialiserArbreMotsCles() {
552
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
553
		MCDao.obtenirListeMotsCles(this);
2 aperonnet 554
	}
5 aperonnet 555
 
2 aperonnet 556
	/**
5 aperonnet 557
	 * Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable
558
	 * donné, qui le demande
559
	 *
560
	 * @param r
561
	 *            le rafraichissable demandeur de l'arbre
2 aperonnet 562
	 */
5 aperonnet 563
	public void obtenirArbreMotCle(Rafraichissable r) {
564
		r.rafraichir(arbreMotsCles, false);
2 aperonnet 565
	}
566
 
567
	/**
5 aperonnet 568
	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
569
	 * fait la mise à jour de l'arbre des mots clés dans la base
570
	 *
571
	 * @param n
572
	 *            le nouveau noeud contenant le mot clé
573
	 * @param arbreMC
574
	 *            l'arbre des mots cles en cours
2 aperonnet 575
	 */
5 aperonnet 576
	public void ajouterMotCleDansArbre(TreeNode n,
577
			com.gwtext.client.data.Tree arbreMC) {
578
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
579
 
580
		String[] usObj = (String[]) n.getUserObject();
581
		String motCle = usObj[0];
582
		String id = usObj[1];
583
		String parentId = "";
584
 
585
		if (!id.equals("racine")) {
586
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
587
			parentId = parentUsObj[1];
588
		} else {
589
			parentId = "racine";
2 aperonnet 590
		}
5 aperonnet 591
 
592
		rafraichirArbreMotsCles(arbreMC);
593
 
594
		String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
595
				+ motCle + "&id=" + id + "&parent=" + parentId;
596
		MCDao.ajouterBaseDeDonnees(nouveauMotCle);
2 aperonnet 597
	}
598
 
599
	/**
5 aperonnet 600
	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
601
	 * supprimer les mots clés associés dans la base
602
	 *
603
	 * @param n
604
	 *            le noeud à supprimer
605
	 * @param arbreMC
606
	 *            l'arbre des mots clés en cours
2 aperonnet 607
	 */
5 aperonnet 608
	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
609
 
610
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
611
 
612
		String[] usObj = (String[]) n.getUserObject();
613
		String id = usObj[1];
614
 
615
		MCDao.supprimerBaseDeDonnees(id);
616
 
2 aperonnet 617
	}
618
 
619
	/**
5 aperonnet 620
	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
621
	 * DAO qui synchronise la modification dans la base de données
622
	 *
623
	 * @param n
624
	 *            le noeud modifié
625
	 * @param arbreMC
626
	 *            l'arbre des mots clés en cours
2 aperonnet 627
	 */
5 aperonnet 628
	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
629
 
630
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
631
 
632
		String[] usObj = (String[]) n.getUserObject();
633
		String motCle = usObj[0];
634
		String id = usObj[1];
635
		String parentId = "";
636
 
637
		if (!id.equals("racine")) {
638
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
639
			parentId = parentUsObj[1];
640
		} else {
641
			parentId = "racine";
2 aperonnet 642
		}
5 aperonnet 643
 
644
		rafraichirArbreMotsCles(arbreMC);
645
 
646
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
647
				+ parentId;
648
		MCDao.modifierBaseDeDonnees(motCleModifie);
649
 
2 aperonnet 650
	}
5 aperonnet 651
 
2 aperonnet 652
	/**
5 aperonnet 653
	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
654
	 * reorganise l'arbre dans la base de donnees suivant le changement
655
	 *
656
	 * @param n
657
	 *            le noeud deplace (et son sous arbre associe)
658
	 * @param arbreMC
659
	 *            l'arbre des mots cles en cours
2 aperonnet 660
	 */
5 aperonnet 661
	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
662
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
663
 
664
		String[] usObj = (String[]) n.getUserObject();
665
		String motCle = usObj[0];
666
		String id = usObj[1];
667
		String parentId = "";
668
		if (!id.equals("racine")) {
669
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
670
			parentId = parentUsObj[1];
671
		} else {
672
			parentId = "racine";
2 aperonnet 673
		}
5 aperonnet 674
 
675
		rafraichirArbreMotsCles(arbreMC);
676
 
677
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
678
				+ parentId;
679
		MCDao.deplacerBaseDeDonnees(motCleModifie);
2 aperonnet 680
	}
5 aperonnet 681
 
2 aperonnet 682
	/**
5 aperonnet 683
	 * Change le numéro de la page en cours et envoie une demande de mise à jour
684
	 * des données
685
	 *
686
	 * @param nouvellePageCourante
687
	 *            la nouvelle page à afficher
2 aperonnet 688
	 */
5 aperonnet 689
	public void changerNumeroPage(int nouvellePageCourante) {
690
		pageEncours = nouvellePageCourante;
691
		obtenirNombrePhotoGalerie(this);
2 aperonnet 692
	}
5 aperonnet 693
 
2 aperonnet 694
	/**
5 aperonnet 695
	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements
696
	 * donnés en fonction de la taille de page en cours
697
	 *
698
	 * @param nbElements
699
	 *            le nombre d'élements total
700
	 * @return le nombre de pages
2 aperonnet 701
	 */
5 aperonnet 702
	public int calculerNbPages(int nbElements) {
703
		// A cause de la betise de java pour les conversion implicite on fait
704
		// quelques conversions manuellement
2 aperonnet 705
		// pour eviter qu'il arrondisse mal la division
5 aperonnet 706
		// nombre de pages = (nombre d'element / taille de la page) arrondie à
707
		// l'entier superieur
708
		double nPage = (1.0 * nbElements) / (1.0 * taillePage);
709
		double nPageRound = Math.ceil(nPage);
710
		Double nPageInt = new Double(nPageRound);
711
 
2 aperonnet 712
		// on convertit en entier
5 aperonnet 713
		return nPageInt.intValue();
2 aperonnet 714
	}
5 aperonnet 715
 
2 aperonnet 716
	/**
717
	 * Recalcule la page en cours lors du changement du nombre d'élements
5 aperonnet 718
	 *
719
	 * @param nbElements
720
	 *            le nombre d'élements total
2 aperonnet 721
	 * @return la nouvelle page encours
722
	 */
5 aperonnet 723
	public int calculerPageCourante(int nbElements) {
2 aperonnet 724
		// on calcule le nombre de page
5 aperonnet 725
		int nouvelNbPages = calculerNbPages(nbElements);
2 aperonnet 726
		// la nouvelle page en cours
5 aperonnet 727
		double nPageCourante = (1.0 * pageEncours) / (1.0 * pageMax)
728
				* (1.0 * nouvelNbPages);
729
 
2 aperonnet 730
		// on arrondit au supérieur
5 aperonnet 731
		double nPageRound = Math.ceil(nPageCourante);
732
		Double nPageInt = new Double(nPageRound);
733
 
2 aperonnet 734
		// on convertit en entier
5 aperonnet 735
		return Math.abs(nPageInt.intValue());
2 aperonnet 736
	}
5 aperonnet 737
 
2 aperonnet 738
	/**
5 aperonnet 739
	 * Change la taille de page et recalcule la page encours
740
	 *
741
	 * @param nouvelleTaillePage
742
	 *            la nouvelle taille de page à utiliser
2 aperonnet 743
	 */
5 aperonnet 744
	public void changerTaillePage(int nouvelleTaillePage) {
745
		taillePage = nouvelleTaillePage;
746
		pageEncours = calculerPageCourante(nbElements);
747
		obtenirNombrePhotoGalerie(this);
2 aperonnet 748
	}
5 aperonnet 749
 
2 aperonnet 750
	/**
5 aperonnet 751
	 * Notifie le mediateur que l'upload ou le download est termine et qu'il
752
	 * faut rafraichir les vues avec les nouvelles données
2 aperonnet 753
	 */
5 aperonnet 754
	public void requeteTerminee() {
755
		getIMediateur().demasquerChargement();
756
		getIMediateur().rafraichirToutesVues();
2 aperonnet 757
	}
758
 
759
	/**
760
	 * Obtient l'identifiant de l'utilisateur auprès du médiateur
5 aperonnet 761
	 *
2 aperonnet 762
	 * @return id de l'utilisateur
763
	 */
764
	public String getIdentifiant() {
5 aperonnet 765
 
766
		return getIMediateur().getIdentifiant();
2 aperonnet 767
	}
768
 
769
	/**
770
	 * renvoie la taille d'une image grâce à son identifiant
5 aperonnet 771
	 *
772
	 * @param id
773
	 *            l'identifiant de l'image
2 aperonnet 774
	 * @return un tableau contenant la longueur et la hauteur de l'image
775
	 */
776
	public String[] obtenirTailleImage(String id) {
5 aperonnet 777
 
778
		return (cacheImage.get(id)).getTailleImage();
779
 
2 aperonnet 780
	}
781
 
782
	/**
5 aperonnet 783
	 * Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il
2 aperonnet 784
	 * renvoie la note associée au rafrachissable qui la demande
5 aperonnet 785
	 *
786
	 * @param r
787
	 *            le rafraichissable demandeur de l'information
788
	 * @param id
789
	 *            l'identifiant del'image
2 aperonnet 790
	 */
791
	public void obtenirNote(Rafraichissable r, String id) {
5 aperonnet 792
 
793
		r.rafraichir((cacheImage.get(id)).getNote(), true);
794
 
2 aperonnet 795
	}
5 aperonnet 796
 
2 aperonnet 797
	/**
798
	 * Accesseur pour la configuration en cours d'utilisation
5 aperonnet 799
	 *
2 aperonnet 800
	 * @return la configuration
801
	 */
802
	public Configuration getConfig() {
5 aperonnet 803
 
804
		return config;
805
	}
806
 
807
	/**
808
	 * Ajoute des images à la selection en cours
809
	 *
810
	 * @param ids
811
	 *            les identifiants des images à ajouter
812
	 */
813
	public void ajouterImagesSelection(String[] ids) {
814
 
815
		for (int i = 0; i < ids.length; i++) {
816
 
817
			selectionImages.add(ids[i]);
818
		}
819
	}
820
 
821
	/**
822
	 * Vide la selection en cours
823
	 */
824
	public void viderSelection() {
825
		selectionImages.clear();
826
	}
827
 
828
	public String renvoyerSelection() {
829
 
830
		String selection = "";
2 aperonnet 831
 
5 aperonnet 832
		if(selectionImages.size() <= 0)
833
		{
834
			selection += "-255" ;
835
		}
836
		else
837
		{
838
			for (Iterator<String> it = selectionImages.iterator(); it.hasNext();) {
839
 
840
				String idEncours = it.next();
841
				selection += idEncours + ",";
842
			}
843
		}
844
 
845
		return selection;
2 aperonnet 846
	}
5 aperonnet 847
 
848
	public void lierImagesObervations(String idsObs, String idsImg) {
849
 
850
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
851
		lienDAO.lierImageBaseDeDonnees(idsImg, idsObs) ;
852
 
853
	}
854
 
81 jpm 855
	public void obtenirLiaisonObservations(ImageMediateur imageMediateur,
856
			String id) {
857
 
858
		String imgId = cacheImage.get(id).getId() ;
859
 
860
		LienImageAsynchroneDAO lienDao = new LienImageAsynchroneDAO(this) ;
861
		lienDao.obtenirLiaisonsImagesObservations(this, imgId) ;
862
 
863
	}
864
 
104 jpm 865
	public void supprimerLiaisonImages(String idImg, String idObs) {
866
 
867
		idImg = cacheImage.get(idImg).getId() ;
868
 
869
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
870
		lienDAO.supprimerLienImageObservation(idImg, idObs) ;
871
	}
872
 
2 aperonnet 873
}