Subversion Repositories eFlore/Applications.cel

Rev

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