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