Subversion Repositories eFlore/Applications.cel

Rev

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