Subversion Repositories eFlore/Applications.cel

Rev

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