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