Subversion Repositories eFlore/Applications.cel

Rev

Rev 156 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 aperonnet 1
package org.tela_botanica.client.observation;
2
 
3
 
54 david 4
//TODO : normaliser les noms de methodes (obtenir, ajouter ...)
2 aperonnet 5
 
156 aurelien 6
import java.util.HashMap;
7
import org.tela_botanica.client.interfaces.FournisseurListe;
12 david 8
import org.tela_botanica.client.interfaces.Rafraichissable;
9
import org.tela_botanica.client.modeles.Configuration;
101 jpm 10
import org.tela_botanica.client.modeles.ExportObservationsDAO;
156 aurelien 11
import org.tela_botanica.client.modeles.ImageAsynchroneDAO;
12
import org.tela_botanica.client.modeles.ImageCarnet;
54 david 13
import org.tela_botanica.client.modeles.ImageGeneriqueVueAsynchroneDAO;
14
import org.tela_botanica.client.modeles.ImageInformationRepartitionAsynchroneDAO;
156 aurelien 15
import org.tela_botanica.client.modeles.ImportObservationAsynchroneDAO;
94 jpm 16
import org.tela_botanica.client.modeles.LienImageAsynchroneDAO;
91 jpm 17
import org.tela_botanica.client.modeles.ListeDateObservationAsynchroneDAO;
66 david 18
import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservationAsynchroneDAO;
156 aurelien 19
import org.tela_botanica.client.modeles.ListeObservation;
12 david 20
import org.tela_botanica.client.modeles.ListeObservationAsynchroneDAO;
21
import org.tela_botanica.client.modeles.ListeReferentielCommuneAsynchroneDAO;
20 david 22
import org.tela_botanica.client.modeles.ListeReferentielNomAsynchroneDAO;
156 aurelien 23
import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;
115 aurelien 24
import org.tela_botanica.client.modeles.MotsClesObsAsynchronesDAO;
140 aurelien 25
import org.tela_botanica.client.modeles.NomRetenuAsynchroneDao;
12 david 26
import org.tela_botanica.client.modeles.NombreObservationAsynchroneDAO;
39 david 27
import org.tela_botanica.client.modeles.Observation;
20 david 28
import org.tela_botanica.client.modeles.ObservationAsynchroneDAO;
108 aurelien 29
import org.tela_botanica.client.modeles.TransmissionObservationAsynchroneDAO;
217 aurelien 30
import org.tela_botanica.client.vues.observation.ListeObservationVue;
31
 
156 aurelien 32
import com.google.gwt.json.client.JSONArray;
33
import com.google.gwt.json.client.JSONObject;
34
import com.gwtext.client.data.Node;
35
import com.gwtext.client.data.Tree;
36
import com.gwtext.client.widgets.tree.TreeNode;
2 aperonnet 37
 
7 aperonnet 38
 
156 aurelien 39
public class ObservationModele implements Rafraichissable {
7 aperonnet 40
 
12 david 41
 
42
 
43
	/**
44
	 * Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)
45
	 */
46
	private static boolean estInstancie = false ;
47
 
88 jpm 48
	private static ObservationModele thisModele = null ;
12 david 49
 
88 jpm 50
 
152 david 51
 
52
 
12 david 53
	/**
54
	 * La configuration en cours
55
	 */
56
	private Configuration config = null;
7 aperonnet 57
 
12 david 58
 
59
	/**
60
	 * Le médiateur associé au modèle
61
	 */
62
 
63
	private ObservationMediateur observationMediateur = null ;
64
 
156 aurelien 65
	/**
66
	 * La liste des mots clés en cours
67
	 */
68
	private HashMap<String, String> motsCles = new HashMap<String, String>(0);
12 david 69
 
156 aurelien 70
	private Tree arbreMotsCles = new Tree() ;
12 david 71
 
152 david 72
	/**
156 aurelien 73
	 * La liste des observations affichées en cours (verifier utilité)
74
	 */
75
 
76
	private ListeObservation cacheObservation = new ListeObservation(0) ;
77
 
78
	/**
152 david 79
	 * DAO dont le resultat peut etre mis en cache
80
	 *
81
	 */
82
 
83
	private ListeReferentielNomAsynchroneDAO nomDAO=null;
84
	private ListeReferentielCommuneAsynchroneDAO refDAO=null;
85
 
12 david 86
 
152 david 87
 
88
 
12 david 89
	/**
90
	 * Retourne une instance de manière unique
91
	 * @param im le médiateur à associer
92
	 * @return l'instance du modèle
93
	 */
94
 
95
	static ObservationModele Instance(ObservationMediateur observationMediateur)
96
	{
97
		// si le modèle n'est pas encore instancié
98
		if(!estInstancie)
99
		{
100
			// on en crée un nouveau
101
			estInstancie = true ;
88 jpm 102
			thisModele = new ObservationModele(observationMediateur);
12 david 103
		}
88 jpm 104
		return thisModele ;
2 aperonnet 105
	}
106
 
12 david 107
 
108
 
109
	private ObservationModele(ObservationMediateur observationMediateur) {
110
 
111
		this.observationMediateur=observationMediateur;
112
 
113
		config = new Configuration();
2 aperonnet 114
 
12 david 115
 
116
	}
2 aperonnet 117
 
12 david 118
 
119
 
120
	/**
121
	 * Appelle le DAO asynchrone pour obtenir le nombre d'observation
122
	 * @param r le rafraichissable auxquel on enverra les données
86 jpm 123
	 * @param filtrage
12 david 124
	 * @param taillePage
125
	 */
126
	public void obtenirNombreObservation(Rafraichissable r) {
86 jpm 127
 
128
		String[][] criteres = {{"",""}} ;
129
		 	criteres = observationMediateur.renvoyerFiltres() ;
12 david 130
			// on rassemble les critères
131
 
132
 
133
			// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
134
 
135
			NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this) ;
136
			noaDAO.obtenirNombreObservation(r, observationMediateur.getIdentifiant(), criteres) ;
137
 
2 aperonnet 138
	}
12 david 139
 
140
 
217 aurelien 141
	public void obtenirListeObservation(Rafraichissable r) {
142
		obtenirListeObservation(r,observationMediateur.getTaillePage(),observationMediateur.getPageEnCours());
143
	}
144
 
12 david 145
	/**
146
	 * Appelle le DAO asynchrone pour obtenir la liste des images
147
	 * @param r le rafraichissable auxquel on enverra les données
148
	 * @param taillePage
149
	 */
150
	public void obtenirListeObservation(Rafraichissable r, int taillePage, int pageEncours) {
151
 
86 jpm 152
 
89 jpm 153
		 	String[][] criteres = {{"",""}} ;
154
				criteres = observationMediateur.renvoyerFiltres() ;
86 jpm 155
				// on rassemble les critères
12 david 156
 
157
 
158
			// ensuite on demande la page correspondante avec les mêmes critères
89 jpm 159
			String[][] criteres2 = new String[criteres.length+2][2] ;
12 david 160
 
89 jpm 161
			criteres2[0][0] = "limite" ;
162
			criteres2[0][1] = ""+taillePage ;
163
			criteres2[1][0] = "numero_page" ;
164
			criteres2[1][1] = ""+pageEncours ;
165
			for(int i = 0 ; i < criteres.length ; i++)
166
			{
167
				criteres2[i+2][0] = criteres[i][0] ;
168
				criteres2[i+2][1] = criteres[i][1] ;
169
			}
170
 
12 david 171
			// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
172
			ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
173
			loaDAO.obtenirListeObservation(r, observationMediateur.getIdentifiant(), criteres2);
174
	}
175
 
2 aperonnet 176
 
54 david 177
	/**
178
	 * Obtenir une liste de commune
179
	 * @param r
180
	 * @param critere
181
	 */
12 david 182
 
13 david 183
	public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
12 david 184
 
152 david 185
		if (refDAO==null) {
186
			refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
187
		}
13 david 188
		ListeReferentielCommuneAsynchroneDAO refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
189
		refDAO.obtenirListeDonnees(r, critere);
190
 
12 david 191
	}
20 david 192
 
54 david 193
	/**
194
	 * Obtenir une liste de nom scientifique de plante
195
	 * @param r
196
	 * @param critere
197
	 */
20 david 198
 
199
	public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
200
 
152 david 201
		if (nomDAO==null) {
202
			nomDAO=new ListeReferentielNomAsynchroneDAO(this);
203
		}
20 david 204
		nomDAO.obtenirListeDonnees(r, critere);
205
 
206
	}
207
 
208
 
209
	/**
210
	 *
211
	 * Lance la creation d'une observation
212
	 * @param r : la vue demandeuse de donnee
213
	 * @param critere : les criteres de selection
214
	 */
215
 
39 david 216
	public void ajouterObservation(Rafraichissable r, Observation obs) {
20 david 217
 
218
		ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
39 david 219
		obsDAO.ajouter(r, observationMediateur.getIdentifiant(), obs);
20 david 220
 
221
	}
2 aperonnet 222
 
74 david 223
	/**
224
	 *
225
	 * Lance la creation d'une observation
226
	 * @param r : la vue demandeuse de donnee
227
	 * @param critere : les criteres de selection
228
	 */
20 david 229
 
79 david 230
	public void modifierObservation(Rafraichissable r, Observation obs) {
74 david 231
 
232
		ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
79 david 233
		obsDAO.modifier(r, observationMediateur.getIdentifiant(), obs);
74 david 234
 
235
	}
20 david 236
 
217 aurelien 237
 
238
 
239
	public void modifierObservationEnMasse(
240
			Rafraichissable r, Observation obs) {
241
		ListeObservationAsynchroneDAO liObsDAO=new ListeObservationAsynchroneDAO(this);
242
		liObsDAO.modifierEnMasse(r, observationMediateur.getIdentifiant(), obs);
243
 
244
	}
245
 
246
 
247
 
77 jpm 248
	public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
249
 
250
		ObservationAsynchroneDAO obsDao = new ObservationAsynchroneDAO(this) ;
251
		obsDao.supprimer(r,observationMediateur.getIdentifiant(),numeroOrdre) ;
252
 
253
 
254
	}
74 david 255
 
77 jpm 256
 
7 aperonnet 257
 
20 david 258
 
12 david 259
	/**
260
	 * Accesseur pour la configuration en cours d'utilisation
261
	 *
262
	 * @return la configuration
263
	 */
264
	public Configuration getConfig() {
265
 
266
		return config;
2 aperonnet 267
	}
268
 
66 david 269
 
270
	/**
271
	 * Obtenir des informations de repartition relative a un numero nomenclatural
272
	 * @param r
273
	 * @param numeroNomenclaturalSaisiObservation
274
	 */
12 david 275
 
54 david 276
 
277
	public void obtenirImageInformationRepartition( Rafraichissable r,String numeroNomenclaturalSaisiObservation) {
278
 
279
		ImageInformationRepartitionAsynchroneDAO repDAO=new ImageInformationRepartitionAsynchroneDAO(this);
280
		repDAO.obtenirURLImage(r, numeroNomenclaturalSaisiObservation);
281
 
282
 
283
	}
284
 
66 david 285
	/**
286
	 * Obtenir une image generique associee a un numero nomenclatural
287
	 * @param r
288
	 * @param numeroNomenclaturalSaisiObservation
289
	 */
54 david 290
 
291
	public void obtenirImageGenerique( Rafraichissable r,String numeroNomenclaturalSaisiObservation) {
292
 
293
		ImageGeneriqueVueAsynchroneDAO imgDAO=new ImageGeneriqueVueAsynchroneDAO(this);
294
		imgDAO.obtenirURLImage(r, numeroNomenclaturalSaisiObservation);
295
 
296
 
297
	}
298
 
299
 
66 david 300
	/**
301
	 * Obtenir la liste de l'ensemble des entites geographiques associes aux observation d'un utilisateur
302
	 * @param r
303
	 */
54 david 304
 
66 david 305
	public void obtenirListeEntiteGeographique(Rafraichissable r) {
54 david 306
 
66 david 307
	    ListeEntiteGeographiqueObservationAsynchroneDAO entDAO = new ListeEntiteGeographiqueObservationAsynchroneDAO(this);
308
	    entDAO.obtenirListeEntitesGeographiques(r, observationMediateur.getIdentifiant());
54 david 309
 
310
	}
91 jpm 311
 
312
 
313
 
314
	public void obtenirDatesObservation(
315
			Rafraichissable r) {
316
	    ListeDateObservationAsynchroneDAO ldoDAO = new ListeDateObservationAsynchroneDAO(this);
317
	    ldoDAO.obtenirListeDate(r, observationMediateur.getIdentifiant());
318
 
319
	}
94 jpm 320
 
321
 
322
 
323
	public void obtenirLiaisonImage(Rafraichissable r,
324
			String ordreObservation) {
325
 
326
		LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ;
327
		liaDAO.obtenirLiaisonsObservationsImages(r, ordreObservation,observationMediateur.getIdentifiant()) ;
328
 
329
	}
101 jpm 330
 
331
 
332
 
333
	public void exporterObservations() {
334
 
335
		String[][] criteres = {{"",""}} ;
336
	 	criteres = observationMediateur.renvoyerFiltres() ;
337
		// on rassemble les critères
338
 
339
 
340
		// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
341
 
342
		ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
343
		exoDAO.exporterObservations(observationMediateur.getIdentifiant(), criteres) ;
344
 
345
 
346
	}
104 jpm 347
 
348
 
349
 
350
	public void supprimerLiaisonImages(String idImg, String idObs) {
351
 
352
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
353
		lienDAO.supprimerLienImageObservation(idImg, idObs) ;
354
 
355
	}
356
 
357
 
358
 
359
	public String getIdentifiant() {
360
 
361
		return observationMediateur.getIdentifiant() ;
362
	}
107 aurelien 363
 
364
 
365
 
366
	public void supprimerListeObservation(Rafraichissable r,
367
			String numObs) {
368
		ListeObservationAsynchroneDAO lioaDAO = new ListeObservationAsynchroneDAO(this);
369
		lioaDAO.supprimerListeObservation(r, observationMediateur.getIdentifiant(), numObs);
370
 
371
	}
108 aurelien 372
 
373
 
374
 
375
	public void transmettreListeObservation(
145 aurelien 376
			Rafraichissable r, String numObsapl, boolean publier) {
108 aurelien 377
		TransmissionObservationAsynchroneDAO toaDAO = new TransmissionObservationAsynchroneDAO(this);
145 aurelien 378
		toaDAO.transmettreObservations(r, observationMediateur.getIdentifiant(), numObsapl, publier);
108 aurelien 379
 
380
	}
115 aurelien 381
 
382
 
383
 
384
	public void obtenirNuageMotsCles(Rafraichissable r) {
385
 
386
		MotsClesObsAsynchronesDAO mcoaDAO = new MotsClesObsAsynchronesDAO(this);
387
		mcoaDAO.obtenirMotsClesObservations(r);
388
 
389
	}
390
 
391
 
392
 
393
	public void ajouterMotsCles(Rafraichissable r,
394
			String numObsApl, String motsAAjouter) {
395
 
396
		MotsClesObsAsynchronesDAO moadDAO = new MotsClesObsAsynchronesDAO(this);
397
		moadDAO.ajouterMotsCles(r,numObsApl,motsAAjouter);
398
 
399
	}
140 aurelien 400
 
401
 
402
 
403
	public void analyserHistorique(Rafraichissable r,String anum) {
404
 
405
		NomRetenuAsynchroneDao nraDAO = new NomRetenuAsynchroneDao(this);
406
		nraDAO.obtenirNomRetenu(r, anum);
407
 
408
	}
409
 
410
 
411
 
412
	public void importerObservations() {
413
		ImportObservationAsynchroneDAO ioDAO = new ImportObservationAsynchroneDAO(this);
414
		ioDAO.importerObservations();
415
 
416
	}
156 aurelien 417
 
418
 
419
 
420
	public void obtenirArbreMotsCles(Rafraichissable r) {
421
 
422
		MotsClesAsynchroneDAO mcoDAO = new MotsClesAsynchroneDAO(this);
423
		mcoDAO.obtenirListeMotsCles(this);
424
 
425
	}
426
 
427
	public void rafraichir(Object nouvelleDonnees,
428
			boolean repandreRaffraichissement) {
429
 
430
		if(nouvelleDonnees instanceof JSONArray) {
431
			// alors on a reçu les informations sur les mots clés
432
			JSONArray reponse = (JSONArray) nouvelleDonnees;
433
 
434
			final int taillemax = reponse.size();
435
 
436
			// si le tableau est vide
437
			if (taillemax == 0) {
438
				// on crée un arbre vide
439
				TreeNode root = new TreeNode();
440
				root.setId("racine");
441
				root.setText("Tags");
442
				String[] usObj = { "Tags", "racine" };
443
				root.setUserObject(usObj);
444
				arbreMotsCles.setRootNode(root);
445
			}
446
 
447
			// pour chacun des élements du tableau
448
			for (int j = 0; j < taillemax; j++) {
449
				// on extrait les élements du tableau
450
				if (reponse.get(j).isObject() != null) {
451
					JSONObject noeud = (JSONObject) reponse.get(j);
452
 
453
					String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur")
454
							.isString().stringValue();
455
					String mot_cle = noeud.get("cmc_mot_cle").isString()
456
							.stringValue();
457
					String parent = noeud.get("cmc_id_parent").isString()
458
							.stringValue();
459
 
460
					String[] usObj = { mot_cle, id_noeud };
461
 
462
					// et on construit l'arbre à partir de la racine (qui est
463
					// toujoursl e premier élément)
464
					if (id_noeud.equals("racine")) {
465
						TreeNode root = new TreeNode();
466
						root.setId(id_noeud);
467
						root.setText(mot_cle);
468
						root.setUserObject(usObj);
469
						arbreMotsCles.setRootNode(root);
470
					} else {
471
						// et en ajoutant les noeuds un à un (qui sont renvoyé
472
						// dans l'ordre hierarchique de leur niveau
473
						// ce qui permet de les traiter séquentiellement)
474
						TreeNode node = new TreeNode();
475
						node.setId(id_noeud);
476
						node.setText(mot_cle);
477
						node.setChecked(false);
478
						Node parentNode = arbreMotsCles.getNodeById(parent);
479
						node.setUserObject(usObj);
480
						parentNode.appendChild(node);
481
					}
482
				}
483
			}
484
			// enfin on met à jour l'arbre des mots clés contenu dans le modèle
485
			rafraichirArbreMotsCles(arbreMotsCles);
486
			// et on notifie le médiateur de la mise à jour en lui passant une
487
			// copie des données
488
			observationMediateur.rafraichirArbreMotsCles(arbreMotsCles);
489
		}
490
 
491
	}
492
 
493
	/**
494
	 * Met à jour l'arbre des mots clés à partir d'un objet
495
	 *
496
	 * @param o
497
	 *            le nouvel arbre de mots clés
498
	 */
499
	public void rafraichirArbreMotsCles(Object o) {
500
		observationMediateur.transmettreDonnees(o);
501
		arbreMotsCles = (com.gwtext.client.data.Tree) o;
502
	}
503
 
504
	/**
505
	 * Met à jour la table de correspondance mots clés / ids à partir d'un objet
506
	 *
507
	 * @param o
508
	 *            la nouvelle table des mots clés
509
	 */
510
	@SuppressWarnings("unchecked")
511
	public void rafraichirMotsCles(Object o) {
512
		if (o instanceof HashMap) {
513
			motsCles = (HashMap<String, String>) o;
514
		}
515
	}
12 david 516
 
156 aurelien 517
	/**
518
	 * Va chercher les mots clés associés à une image dans la liste des images
519
	 * chargée dans le modèle
520
	 *
521
	 * @param r
522
	 *            le rafraichissable auquel on enverra les informations
523
	 * @param id
524
	 *            l'identifiant de l'image
525
	 */
526
	public void obtenirMotsClesId(Rafraichissable r, String id) {
527
		Observation o = cacheObservation.get(id);
528
		String motsClesId = o.getMotsCles();
529
		String[] motsClesIdTab = motsClesId.split(",");
530
		r.rafraichir(motsClesIdTab, false);
531
	}
532
 
533
	/**
534
	 * Met à jour les mots clés associés à une image et appelle le DAO pour
535
	 * synchroniser la base de données
536
	 *
537
	 * @param ids
538
	 *            les identifiants des images selectionnées
539
	 * @param motsClesEnCours
540
	 *            les mots clés à appliquer aux images
541
	 * @param arbreMC
542
	 *            l'arbre de mots clés en cours
543
	 */
544
	public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,
545
			com.gwtext.client.data.Tree arbreMC) {
546
		for (int i = 0; i < ids.length; i++) {
547
			if (cacheObservation.containsKey(ids[i])) {
548
				Observation o = (Observation) cacheObservation.get(ids[i]);
549
				o.setMotsCles(motsClesEnCours);
550
 
551
				ObservationAsynchroneDAO oDao = new ObservationAsynchroneDAO(this);
552
				oDao.modifier(this,observationMediateur.getIdentifiant(),o);
553
			}
554
		}
555
 
556
		rafraichirArbreMotsCles(arbreMC);
557
	}
558
 
559
	/**
560
	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
561
	 * fait la mise à jour de l'arbre des mots clés dans la base
562
	 *
563
	 * @param n
564
	 *            le nouveau noeud contenant le mot clé
565
	 * @param arbreMC
566
	 *            l'arbre des mots cles en cours
567
	 */
568
	public void ajouterMotCleDansArbre(TreeNode n,
569
			com.gwtext.client.data.Tree arbreMC) {
570
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
571
 
572
		String[] usObj = (String[]) n.getUserObject();
573
		String motCle = usObj[0];
574
		String id = usObj[1];
575
		String parentId = "";
576
 
577
		if (!id.equals("racine")) {
578
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
579
			parentId = parentUsObj[1];
580
		} else {
581
			parentId = "racine";
582
		}
583
 
584
		rafraichirArbreMotsCles(arbreMC);
585
 
586
		String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
587
				+ motCle + "&id=" + id + "&parent=" + parentId;
588
		MCDao.ajouterBaseDeDonnees(nouveauMotCle);
589
	}
590
 
591
	/**
592
	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
593
	 * supprimer les mots clés associés dans la base
594
	 *
595
	 * @param n
596
	 *            le noeud à supprimer
597
	 * @param arbreMC
598
	 *            l'arbre des mots clés en cours
599
	 */
600
	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
601
 
602
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
603
 
604
		String[] usObj = (String[]) n.getUserObject();
605
		String id = usObj[1];
606
 
607
		MCDao.supprimerBaseDeDonnees(id);
608
 
609
	}
610
 
611
	/**
612
	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
613
	 * DAO qui synchronise la modification dans la base de données
614
	 *
615
	 * @param n
616
	 *            le noeud modifié
617
	 * @param arbreMC
618
	 *            l'arbre des mots clés en cours
619
	 */
620
	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
621
 
622
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
623
 
624
		String[] usObj = (String[]) n.getUserObject();
625
		String motCle = usObj[0];
626
		String id = usObj[1];
627
		String parentId = "";
628
 
629
		if (!id.equals("racine")) {
630
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
631
			parentId = parentUsObj[1];
632
		} else {
633
			parentId = "racine";
634
		}
635
 
636
		rafraichirArbreMotsCles(arbreMC);
637
 
638
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
639
				+ parentId;
640
		MCDao.modifierBaseDeDonnees(motCleModifie);
641
 
642
	}
643
 
644
	/**
645
	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
646
	 * reorganise l'arbre dans la base de donnees suivant le changement
647
	 *
648
	 * @param n
649
	 *            le noeud deplace (et son sous arbre associe)
650
	 * @param arbreMC
651
	 *            l'arbre des mots cles en cours
652
	 */
653
	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
654
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
655
 
656
		String[] usObj = (String[]) n.getUserObject();
657
		String motCle = usObj[0];
658
		String id = usObj[1];
659
		String parentId = "";
660
		if (!id.equals("racine")) {
661
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
662
			parentId = parentUsObj[1];
663
		} else {
664
			parentId = "racine";
665
		}
666
 
667
		rafraichirArbreMotsCles(arbreMC);
668
 
669
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
670
				+ parentId;
671
		MCDao.deplacerBaseDeDonnees(motCleModifie);
672
	}
673
 
674
	/**
675
	 * Ajoute un nouveau mot clés à la liste des mots clés locale
676
	 *
677
	 * @param text
678
	 *            le mot clé
679
	 * @param id
680
	 *            l'identifiant du mot clé
681
	 */
682
	public void mettreAjourMotsClesId(String text, String id) {
683
		motsCles.put(id, text);
684
	}
685
 
686
	public void rafraichirCacheObservation(ListeObservation li) {
687
		cacheObservation = li ;
688
	}
689
 
690
	public ListeObservation getCacheObservation() {
691
		return cacheObservation ;
692
	}
693
 
694
 
2 aperonnet 695
}