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