Subversion Repositories eFlore/Applications.cel

Rev

Rev 31 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 aperonnet 1
package org.tela_botanica.client.observation;
2
 
12 david 3
 
4
import java.util.Iterator;
2 aperonnet 5
import org.tela_botanica.client.CarnetEnLigneMediateur;
12 david 6
import org.tela_botanica.client.interfaces.FournisseurListe;
7
import org.tela_botanica.client.interfaces.Rafraichissable;
8
import org.tela_botanica.client.modeles.ListeObservation;
2 aperonnet 9
import org.tela_botanica.client.modeles.Observation;
12 david 10
import org.tela_botanica.client.vues.FormulaireSaisieObservationVue;
11
import org.tela_botanica.client.vues.ListeObservationVue;
2 aperonnet 12
 
12 david 13
import com.gwtext.client.data.ArrayReader;
14
import com.gwtext.client.data.FieldDef;
15
import com.gwtext.client.data.MemoryProxy;
16
import com.gwtext.client.data.RecordDef;
17
import com.gwtext.client.data.Store;
18
import com.gwtext.client.data.StringFieldDef;
19
import com.gwtext.client.widgets.Panel;
20
import com.gwtext.client.widgets.TabPanel;
2 aperonnet 21
 
12 david 22
/**
23
 * Mediateur gérant les interactions entre vues et les echanges de données
24
 * C'est un singleton.
25
 * @author aurelien
26
 *
27
 */
28
public class ObservationMediateur implements Rafraichissable {
29
 
30
	/**
31
	 * booleen qui verifie l'unicite de l'instance (donc static)
32
	 */
31 jpm 33
	private static boolean estInstancie = false ;
34
 
35
	/**
36
	 * pointeur sur le médiateur (pour le pattern singleton)
37
	 */
38
	private static ObservationMediateur thisMediateur = null ;
12 david 39
 
40
	/** Mediateur general de l'application carnet en ligne
41
	 *
42
	 *
43
	 */
44
 
45
	private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
46
 
47
 
48
	/**
49
	 * modele de données
50
	 */
51
	private ObservationModele observationModele = null ;
52
 
53
 
54
	/**
55
	 * panneau principal des Observation (onglet "observation")
56
	 */
57
	private final Panel panneauPrincipalObservation = new Panel("Observation");
58
 
59
	/**
60
	 * panneau a onglet pour la liste
61
	 */
62
	private TabPanel ongletsObservation = null ;
63
 
64
	/**
65
	 * conteneur du panneau a onglets
66
	 */
67
	private Panel panneauMenuEtOngletsObservation = null ;
68
 
69
	/**
70
	 * liste détaillée des Observations
71
	 */
72
	private ListeObservationVue listeObservation = null ;
73
 
74
	/**
75
	 * Saisie des Observations
76
	 */
77
 
78
	private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null;
79
	/**
80
	 * l'indice du dernier onglet sélectionné
81
	 */
82
	private int dernierIndexOnglet = 0 ;
83
 
84
	/**
85
	 * booleen explicitant s'il y a une selection en cours
86
	 */
87
	private boolean selection = false ;
88
 
89
	/**
90
	 * Numéro de page en cours
91
	 */
92
	private int pageEncours = 0 ;
93
	/**
94
	 * Nombre de pages totales
95
	 */
96
	private int pageMax = 1 ;
97
	/**
98
	 * Taille de page (par défaut 20)
99
	 */
100
	private int taillePage = 20 ;
101
	/**
102
	 * Nombre d'éléments total correspondant à la requete
103
	 */
104
	private int nbElements = 0 ;
105
 
106
 
107
	/**
108
	 * Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande
109
	 */
110
	private Store st = null ;
111
 
112
 
113
 
114
 
115
	/**
116
	 * La liste des observations affichées en cours (verifier utilité)
117
	 */
118
 
119
	private ListeObservation cacheObservation = new ListeObservation(0) ;
120
	/**
121
 
122
 
123
 
124
	/**
125
	 * constructeur privé (on accède a la classe par la méthode getInstance
126
	 */
127
 
128
 
129
	private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
130
	{
131
		this.carnetEnLigneMediateur=carnetEnLigneMediateur;
132
 
133
 
134
 
135
		// Demande d'identification
136
//		afficherMenuId() ;
2 aperonnet 137
 
12 david 138
 
139
		// on crée un modèle
140
		observationModele = ObservationModele.Instance(this);
141
 
142
 
143
		// on gère la mise en page du panneau principal
144
		//panneauPrincipalObservation.setLayout(new BorderLayout());
145
 
146
		// on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur
147
	//	panneauMenuEtOngletsObservation = new Panel("gg") ;
148
	//	panneauMenuEtOngletsObservation.setLayout(new BorderLayout()) ;
149
 
150
		// le panneau à onglet qui contient la vue
151
		//ongletsObservation = new TabPanel();
152
 
153
 
154
		// la liste des observations
155
 
156
		//Panel panneauListeObservation = new Panel("Liste");
157
 
158
		listeObservation = new ListeObservationVue(this);
159
 
160
 
161
		// Le formulaire de saisie / modification d'observation
162
 
163
		formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
2 aperonnet 164
 
12 david 165
 
166
		//panneauListeObservation.setLayout(new FitLayout());
167
		//panneauListeObservation.setSize(600,600);
168
		//panneauListeObservation.add(listeObservation);
169
 
170
 
171
		// on ajoute les panneaux au panneau à onglets
172
		//ongletsObservation.add(panneauListeObservation);
173
 
174
 
175
		// les onglets au centre
176
//		panneauMenuEtOngletsObservation.add(ongletsObservation,regionCentre);
177
 
178
		// on ajoute le panneau qui contient le menu et les onglets d'images au centre
179
		//panneauPrincipalObservation.add(panneauMenuEtOngletsObservation,regionCentre);
180
 
181
		panneauPrincipalObservation.add(formulaireSaisieObservationVue);
182
 
183
		panneauPrincipalObservation.add(listeObservation);
184
 
185
 
186
 
2 aperonnet 187
 
12 david 188
	}
2 aperonnet 189
 
7 aperonnet 190
 
12 david 191
	/**
192
	 * Retourne une instance de manière unique
193
	 * @return l'instance unique du médiateur
194
	 */
195
	public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur)
196
	{
31 jpm 197
			if(!estInstancie || thisMediateur == null)
12 david 198
			{
199
				estInstancie = true ;
31 jpm 200
				thisMediateur = new ObservationMediateur(carnetEnLigneMediateur) ;
12 david 201
			}
31 jpm 202
 
203
			return thisMediateur ;
12 david 204
	}
205
 
206
 
207
 
208
	/**
209
	 * envoie au modèle une demande de mise a jour
210
	 */
2 aperonnet 211
 
7 aperonnet 212
 
12 david 213
	public void obtenirNombreObservation() {
214
 
215
 
216
			listeObservation.masquerChargement();
217
		    observationModele.obtenirNombreObservation(this) ;
218
 
2 aperonnet 219
	}
12 david 220
 
2 aperonnet 221
	/**
12 david 222
	 * envoie au modèle une demande de mise a jour
2 aperonnet 223
	 */
7 aperonnet 224
 
225
 
12 david 226
	public void obtenirListeObservation() {
227
 
7 aperonnet 228
 
12 david 229
			observationModele.obtenirListeObservation(this, taillePage, pageEncours) ;
230
 
31 jpm 231
	}
12 david 232
 
2 aperonnet 233
	/**
12 david 234
	 * C'est dans cette fonction que doivent être renvoyé les valeurs des filtres
235
	 * sous forme de tableau [nom, valeur]
236
	 * @return Les noms et valeurs des filtres
2 aperonnet 237
	 */
12 david 238
	public String[][] renvoyerFiltres()
239
	{
240
		String[][] valeursFiltres = { {"location","Saint-Martin-de-Londres"} } ;
241
 
242
 
243
		return valeursFiltres ;
244
	}
2 aperonnet 245
 
7 aperonnet 246
 
12 david 247
	public String getIdentifiant() {
248
 
249
		return carnetEnLigneMediateur.getUtilisateur().getIdentifiant();
250
 
251
	}
2 aperonnet 252
 
253
 
12 david 254
	public Panel getPanneauPrincipalObservation() {
255
		return panneauPrincipalObservation;
2 aperonnet 256
	}
12 david 257
 
258
 
259
 
13 david 260
	// FIXME TODO : plutot dans la listevu non ?
2 aperonnet 261
 
12 david 262
	public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
263
 
264
 
265
 
266
//		 si l'on a reçu une liste d'observation
267
		if(nouvelleDonnees instanceof ListeObservation)
268
		{
269
 
270
				ListeObservation data = (ListeObservation) nouvelleDonnees ;
271
				Object[][] observationData = new Object[data.size()][8];
272
				int i = 0 ;
273
 
274
				if(data.size() == 0)
275
				{
276
					pageEncours = 0 ;
277
				}
278
 
279
				// on la parse et on récupère les informations quiç nous interessent
280
				for (Iterator it = data.keySet().iterator(); it.hasNext();)
281
				{
282
 
283
					Observation obs=(Observation) data.get(it.next());
284
 
285
					observationData[i][0]= obs.getTransmis();
286
					observationData[i][1]= obs.getNomSaisi();
287
					observationData[i][2]= obs.getNomRetenu();
288
					observationData[i][3]= obs.getLieudit();
289
					observationData[i][4]= obs.getDate();
31 jpm 290
					observationData[i][5]= obs.getNumeroOrdre();
12 david 291
 
292
					i++ ;
293
				}
294
 
295
				// creation du store qui les contient
296
 
297
				FieldDef defEtatObservation = new StringFieldDef("etat_observation");
298
				FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
299
				FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
300
				FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
301
				FieldDef defDateObservation = new StringFieldDef("date_observation");
302
				FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
303
 
304
				// on associe le store
7 aperonnet 305
 
12 david 306
				FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
307
						defLieuObservation, defDateObservation, defOrdreObservation };
308
 
309
				RecordDef rd = new RecordDef(defTab);
310
 
311
				final MemoryProxy dataProxy = new MemoryProxy(observationData);
312
				final ArrayReader reader = new ArrayReader(rd);
313
 
314
				final Store observationStore = new Store(dataProxy, reader);
315
 
316
 
317
				st = observationStore ;
318
				st.load() ;
319
 
320
				// par défaut le store est trié sur l'ordre d'observations
321
				st.sort("ordre_observation") ;
322
 
323
 
324
				// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
325
				if(repandreRafraichissement)
326
				{
327
					listeObservation.rafraichir(st, false) ;
328
				}
329
 
7 aperonnet 330
		}
12 david 331
 
332
 
333
		// Si on reçoit un tableau d'entiers
334
		// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères
335
		if(nouvelleDonnees instanceof int[])
336
		{
337
			int[] pages = (int[])nouvelleDonnees ;
338
 
339
			// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
340
			pageMax  = calculerNbPages(pages[0]) ;
341
			nbElements = pages[0] ;
342
 
343
			// et on notifie de le mediateur du changement des valeurs
344
			changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
345
 
346
			obtenirListeObservation();
347
		}
2 aperonnet 348
	}
12 david 349
 
350
 
2 aperonnet 351
	/**
12 david 352
	 * Met à jour les barre d'outils avec des nouvelles valeurs
353
	 * @param pageMax le nombre de pages
354
	 * @param pageEncours la page en cours
355
	 * @param taillePage la taille de page
356
	 * @param nbElement le nombre d'élements par page
2 aperonnet 357
	 */
12 david 358
	public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement)
359
	{
360
 
361
		int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
362
		listeObservation.getToolBarVue().rafraichir(pages, false) ;
363
 
2 aperonnet 364
	}
12 david 365
 
366
 
367
 
2 aperonnet 368
	/**
12 david 369
	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
370
	 * en cours
371
	 * @param nbElements le nombre d'élements total
372
	 * @return le nombre de pages
2 aperonnet 373
	 */
12 david 374
	public int calculerNbPages(int nbElements)
375
	{
376
		// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
377
		// pour eviter qu'il arrondisse mal la division
378
		// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur
379
 
380
		double nPage = (1.0*nbElements)/(1.0*taillePage) ;
381
		double nPageRound = Math.ceil(nPage) ;
382
		Double nPageInt = new Double(nPageRound) ;
383
 
384
		// on convertit en entier
385
		return nPageInt.intValue() ;
2 aperonnet 386
	}
387
 
12 david 388
 
2 aperonnet 389
	/**
12 david 390
	 * Recalcule la page en cours lors du changement du nombre d'élements
391
	 * @param nbElements le nombre d'élements total
392
	 * @return la nouvelle page encours
2 aperonnet 393
	 */
12 david 394
	public int calculerPageCourante(int nbElements)
395
	{
396
		// on calcule le nombre de page
397
		int nouvelNbPages = calculerNbPages(nbElements) ;
398
		// la nouvelle page en cours
399
		double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
400
 
401
		// on arrondit au supérieur
402
		double nPageRound = Math.ceil(nPageCourante) ;
403
		Double nPageInt = new Double(nPageRound) ;
404
 
405
		// on convertit en entier
406
		return Math.abs(nPageInt.intValue()) ;
2 aperonnet 407
	}
12 david 408
 
2 aperonnet 409
 
410
	/**
12 david 411
	 * Appelle le modèle pour lui demander les données d'une page à afficher
412
	 * @param pageCourante le numéro de page à affciher
2 aperonnet 413
	 */
12 david 414
	public void changerNumeroPage(int pageCourante) {
415
 
416
 
417
 
418
		pageEncours = pageCourante ;
419
 
420
		// On lance le chargerment des observations
421
		obtenirNombreObservation();
422
 
423
		listeObservation.getToolBarVue().changerPageCourante(pageCourante);
424
 
425
	}
426
 
427
 
428
	/**
429
	 * Appelle le modèle pour qu'il change la taille de page utilisée
430
	 * @param nouvelleTaillePage la nouvelle taille de page
431
	 */
432
 
433
	public void changerTaillePage(int nouvelleTaillePage)
434
	{
435
 
436
		taillePage = nouvelleTaillePage ;
437
		pageEncours = calculerPageCourante(nbElements) ;
2 aperonnet 438
 
12 david 439
		// 	On lance le chargerment des observations
440
		obtenirNombreObservation();
441
 
442
 
443
		// et on met à jour la taille de page dans les barres d'outils
444
		listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
445
 
446
 
2 aperonnet 447
	}
448
 
449
 
13 david 450
	/**
451
	 *
452
	 * Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne
453
	 * @param r : la vue demandeuse de donnee
454
	 * @param critere : les criteres de selection
455
	 */
12 david 456
 
13 david 457
	public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
12 david 458
 
13 david 459
		observationModele.obtenirListeReferentielCommune(r,critere) ;
2 aperonnet 460
 
12 david 461
 
2 aperonnet 462
	}
20 david 463
 
464
	/**
465
	 *
466
	 * Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne
467
	 * @param r : la vue demandeuse de donnee
468
	 * @param critere : les criteres de selection
469
	 */
470
 
471
	public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
472
 
473
		observationModele.obtenirListeReferentielNom(r,critere) ;
2 aperonnet 474
 
20 david 475
 
476
	}
2 aperonnet 477
 
12 david 478
 
20 david 479
	/**
480
	 *
481
	 * Lance la creation d'une observation
482
	 * @param r : la vue demandeuse de donnee
483
	 * @param critere : les criteres de selection
484
	 */
485
 
39 david 486
	public void ajouterObservation(Rafraichissable r, Observation obs) {
20 david 487
 
39 david 488
		observationModele.ajouterObservation(r, obs) ;
20 david 489
 
490
	}
2 aperonnet 491
 
12 david 492
 
493
 
20 david 494
 
495
 
496
 
2 aperonnet 497
}