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