Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

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