Subversion Repositories eFlore/Archives.cel-v2

Compare Revisions

Ignore whitespace Rev 48 → Rev 49

/trunk/src/org/tela_botanica/client/observation/ObservationMediateur.java
1,256 → 1,473
package org.tela_botanica.client.observation;
 
 
 
 
import java.util.Iterator;
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.iMediateur;
import org.tela_botanica.client.interfaces.iRetourObservation;
import org.tela_botanica.client.interfaces.FournisseurListe;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ListeObservation;
import org.tela_botanica.client.modeles.Observation;
import org.tela_botanica.client.vues.FormulaireSaisieObservationVue;
import org.tela_botanica.client.vues.ListeObservationVue;
 
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.TabPanel;
 
public class ObservationMediateur implements iMediateur{
 
 
// Evenenements
final static public int NOMBRE_OBSERVATION=1;
 
final static public int LISTE_OBSERVATION=2;
/**
* Mediateur gérant les interactions entre vues et les echanges de données
* C'est un singleton.
* @author aurelien
*
*/
public class ObservationMediateur implements Rafraichissable {
/**
* booleen qui verifie l'unicite de l'instance (donc static)
*/
private static boolean estInstancie = false ;
private CarnetEnLigneMediateur carnetEnLigneMediateur=null; // Mediateur General
private final ObservationModele observationModele=new ObservationModele();
/** Mediateur general de l'application carnet en ligne
*
*
*/
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
/**
* modele de données
*/
private ObservationModele observationModele = null ;
/**
* panneau principal des Observation (onglet "observation")
*/
private final Panel panneauPrincipalObservation = new Panel("Observation");
/**
* panneau a onglet pour la liste
*/
private TabPanel ongletsObservation = null ;
/**
* conteneur du panneau a onglets
*/
private Panel panneauMenuEtOngletsObservation = null ;
/**
* liste détaillée des Observations
*/
private ListeObservationVue listeObservation = null ;
/**
* Saisie des Observations
*/
private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null;
/**
* l'indice du dernier onglet sélectionné
*/
private int dernierIndexOnglet = 0 ;
/**
* booleen explicitant s'il y a une selection en cours
*/
private boolean selection = false ;
 
private Observation observation=null;
 
// Variable interne
private final String texteDeconnexion="Utilisez ce carnet en ligne pour saisir vos observations, <u>identifiez-vous</u> pour les transmettre à Tela Botanica";
 
// Composants graphiques
/**
*
* Numéro de page en cours
*/
private int pageEncours = 0 ;
/**
* Nombre de pages totales
*/
private int pageMax = 1 ;
/**
* Taille de page (par défaut 20)
*/
private int taillePage = 20 ;
/**
* Nombre d'éléments total correspondant à la requete
*/
private int nbElements = 0 ;
private EtatConnexionVue etatConnexionVue=null; // Vue Etat de la connexion utilisateur
private FormulaireDeConnexionVue formulaireDeConnexionVue=null; // Formulaire de connexion utilisateur
private ListeObservationsVue listeObservationsVue = null; // Liste de releves
/**
* Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande
*/
private Store st = null ;
/**
* La liste des observations affichées en cours (verifier utilité)
*/
private ListeObservation cacheObservation = new ListeObservation(0) ;
/**
/**
* constructeur privé (on accède a la classe par la méthode getInstance
*/
private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
{
this.carnetEnLigneMediateur=carnetEnLigneMediateur;
// Demande d'identification
// afficherMenuId() ;
 
//
public ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur) {
// on crée un modèle
observationModele = ObservationModele.Instance(this);
// on gère la mise en page du panneau principal
//panneauPrincipalObservation.setLayout(new BorderLayout());
// on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur
// panneauMenuEtOngletsObservation = new Panel("gg") ;
// panneauMenuEtOngletsObservation.setLayout(new BorderLayout()) ;
// le panneau à onglet qui contient la vue
//ongletsObservation = new TabPanel();
// la liste des observations
//Panel panneauListeObservation = new Panel("Liste");
listeObservation = new ListeObservationVue(this);
// Le formulaire de saisie / modification d'observation
formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
 
this.carnetEnLigneMediateur=carnetEnLigneMediateur;
etatConnexionVue=new EtatConnexionVue(this);
listeObservationsVue=new ListeObservationsVue(this);
//panneauListeObservation.setLayout(new FitLayout());
//panneauListeObservation.setSize(600,600);
//panneauListeObservation.add(listeObservation);
VerticalPanel panel=new VerticalPanel();
panel.add(etatConnexionVue);
// on ajoute les panneaux au panneau à onglets
//ongletsObservation.add(panneauListeObservation);
// les onglets au centre
// panneauMenuEtOngletsObservation.add(ongletsObservation,regionCentre);
// on ajoute le panneau qui contient le menu et les onglets d'images au centre
//panneauPrincipalObservation.add(panneauMenuEtOngletsObservation,regionCentre);
panneauPrincipalObservation.add(formulaireSaisieObservationVue);
panel.add(listeObservationsVue);
panneauPrincipalObservation.add(listeObservation);
 
RootPanel.get().add(panel);
onInitialisation();
}
 
/// Methodes privees
 
/**
*
* Initialisations
*
* Retourne une instance de manière unique
* @return l'instance unique du médiateur
*/
public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur)
{
if(!estInstancie)
{
estInstancie = true ;
return new ObservationMediateur(carnetEnLigneMediateur) ;
}
else
{
return null ;
}
}
private void onInitialisation() {
afficheEtatConnexion();
onFiltrageListeObservation("all","all","all");
/**
* envoie au modèle une demande de mise a jour
*/
 
 
public void obtenirNombreObservation() {
listeObservation.masquerChargement();
observationModele.obtenirNombreObservation(this) ;
}
// Filtre selection lieu
/**
* Action sur selection d'un lieu : affichage de la liste des taxons correspondants au filtrage
* envoie au modèle une demande de mise a jour
*/
public void onFiltrageListeObservation(String id_loc, String loc,String lieu) {
 
// Positionnement Filtre affichage
listeObservationsVue.setIdLocation(id_loc);
listeObservationsVue.setLocalite(loc);
listeObservationsVue.setLieudit(lieu);
listeObservationsVue.initialiser();
 
// Affichage des filtres
listeObservationsVue.displayFilter();
public void obtenirListeObservation() {
 
observationModele.obtenirListeObservation(this, taillePage, pageEncours) ;
}
 
 
/**
* C'est dans cette fonction que doivent être renvoyé les valeurs des filtres
* sous forme de tableau [nom, valeur]
* @return Les noms et valeurs des filtres
*/
public String[][] renvoyerFiltres()
{
String[][] valeursFiltres = { {"location","Saint-Martin-de-Londres"} } ;
return valeursFiltres ;
}
 
 
public String getIdentifiant() {
return carnetEnLigneMediateur.getUtilisateur().getIdentifiant();
}
 
 
public Panel getPanneauPrincipalObservation() {
return panneauPrincipalObservation;
}
/// UTILISATEUR
// TODO : plutot dans la listevu non ?
 
public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
// si l'on a reçu une liste d'observation
if(nouvelleDonnees instanceof ListeObservation)
{
ListeObservation data = (ListeObservation) nouvelleDonnees ;
Object[][] observationData = new Object[data.size()][8];
int i = 0 ;
if(data.size() == 0)
{
pageEncours = 0 ;
}
// on la parse et on récupère les informations quiç nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
Observation obs=(Observation) data.get(it.next());
observationData[i][0]= obs.getTransmis();
observationData[i][1]= obs.getNomSaisi();
observationData[i][2]= obs.getNomRetenu();
observationData[i][3]= obs.getLieudit();
observationData[i][4]= obs.getDate();
observationData[i][5]= obs.getNumeroOrdre();
 
i++ ;
}
// creation du store qui les contient
FieldDef defEtatObservation = new StringFieldDef("etat_observation");
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
FieldDef defDateObservation = new StringFieldDef("date_observation");
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
// on associe le store
 
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
defLieuObservation, defDateObservation, defOrdreObservation };
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(observationData);
final ArrayReader reader = new ArrayReader(rd);
final Store observationStore = new Store(dataProxy, reader);
st = observationStore ;
st.load() ;
// par défaut le store est trié sur l'ordre d'observations
st.sort("ordre_observation") ;
 
// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
if(repandreRafraichissement)
{
listeObservation.rafraichir(st, false) ;
}
}
// Si on reçoit un tableau d'entiers
// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères
if(nouvelleDonnees instanceof int[])
{
int[] pages = (int[])nouvelleDonnees ;
// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
pageMax = calculerNbPages(pages[0]) ;
nbElements = pages[0] ;
// et on notifie de le mediateur du changement des valeurs
changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
obtenirListeObservation();
}
}
/**
* Affichage etat de la connexion
* Met à jour les barre d'outils avec des nouvelles valeurs
* @param pageMax le nombre de pages
* @param pageEncours la page en cours
* @param taillePage la taille de page
* @param nbElement le nombre d'élements par page
*/
private void afficheEtatConnexion() {
if (!carnetEnLigneMediateur.getUtilisateur().isIdentifie()) {
etatConnexionVue.setEtat(texteDeconnexion,false);
}
else {
etatConnexionVue.setEtat(carnetEnLigneMediateur.getUtilisateur().getIdentifiant()+ " (deconnexion)",true);
}
public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement)
{
int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
listeObservation.getToolBarVue().rafraichir(pages, false) ;
}
 
/**
*
* Affichage boite de connexion
*
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
* en cours
* @param nbElements le nombre d'élements total
* @return le nombre de pages
*/
public void afficherDialogueConnexion() {
public int calculerNbPages(int nbElements)
{
// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
// pour eviter qu'il arrondisse mal la division
// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur
// TODO : singleton ?
formulaireDeConnexionVue = new FormulaireDeConnexionVue(this);
 
// Position it roughly in the middle of the screen.
int left = (Window.getClientWidth() - 512) / 2;
int top = (Window.getClientHeight() - 256) / 2;
formulaireDeConnexionVue.setPopupPosition(left, top);
formulaireDeConnexionVue.show();
double nPage = (1.0*nbElements)/(1.0*taillePage) ;
double nPageRound = Math.ceil(nPage) ;
Double nPageInt = new Double(nPageRound) ;
// on convertit en entier
return nPageInt.intValue() ;
}
 
/**
* Deconnexion de l'utilisateur en cours
* Recalcule la page en cours lors du changement du nombre d'élements
* @param nbElements le nombre d'élements total
* @return la nouvelle page encours
*/
public void deconnecterUtilisateur() {
public int calculerPageCourante(int nbElements)
{
// on calcule le nombre de page
int nouvelNbPages = calculerNbPages(nbElements) ;
// la nouvelle page en cours
double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
// carnetEnLigneMediateur.addListener(CarnetEnLigneMediateur.DECONNEXION,this);
carnetEnLigneMediateur.deconnecterUtilisateur();
// on arrondit au supérieur
double nPageRound = Math.ceil(nPageCourante) ;
Double nPageInt = new Double(nPageRound) ;
// on convertit en entier
return Math.abs(nPageInt.intValue()) ;
}
}
 
 
/**
* Tentative de connexion utilisateur
* @param login
* @param password
* Appelle le modèle pour lui demander les données d'une page à afficher
* @param pageCourante le numéro de page à affciher
*/
public void connecterUtilisateur(String login, String password) {
public void changerNumeroPage(int pageCourante) {
// carnetEnLigneMediateur.addListener(CarnetEnLigneMediateur.CONNEXION,this);
carnetEnLigneMediateur.connecterUtilisateur(login, password);
 
pageEncours = pageCourante ;
// On lance le chargerment des observations
obtenirNombreObservation();
listeObservation.getToolBarVue().changerPageCourante(pageCourante);
}
 
 
/// OBSERVATION
/**
* Recherche nombre d'enregistrement pour l'utilisateur et la localite en cours
*
* Appelle le modèle pour qu'il change la taille de page utilisée
* @param nouvelleTaillePage la nouvelle taille de page
*/
public void changerTaillePage(int nouvelleTaillePage)
{
public void getNombreObservation (String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre ) {
taillePage = nouvelleTaillePage ;
pageEncours = calculerPageCourante(nbElements) ;
 
observationModele.getNombreObservation(
new iRetourObservation() {
public void onRetour(Observation obs) {
observation=obs;
//fireEvent(NOMBRE_OBSERVATION);
}
 
}, carnetEnLigneMediateur.getUtilisateur().getIdentifiant(), identifiantLocalite, localite , annee, mois, jour, lieudit ,rechercheLibre
);
// On lance le chargerment des observations
obtenirNombreObservation();
// et on met à jour la taille de page dans les barres d'outils
listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
}
 
public void getListeObservation (String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre, int debut, int longueur) {
 
observationModele.getListeObservation(
new iRetourObservation() {
public void onRetour(Observation obs) {
observation=obs;
//fireEvent(LISTE_OBSERVATION);
}
// Retourne le fournisseur de donnee en referentiel Commune. doit posseder la methode obtenirListeDonnees()
public FournisseurListe obtenirFournisseurReferentielCommune() {
return observationModele.obtenirFournisseurReferentielCommune() ;
 
}, carnetEnLigneMediateur.getUtilisateur().getIdentifiant(), identifiantLocalite, localite , annee, mois, jour, lieudit ,rechercheLibre, debut, longueur
);
 
}
 
 
public Observation getObservation() {
return observation;
}
 
 
 
/// EVENEMENTS
/**
* Evenements
*
*/
/*
public void handleEvent(BaseEvent be) {
switch (be.type) {
case CarnetEnLigneMediateur.DECONNEXION:
afficheEtatConnexion();
break;
case CarnetEnLigneMediateur.CONNEXION:
if (carnetEnLigneMediateur.getUtilisateur().isIdentifie()) {
formulaireDeConnexionVue.hide();
afficheEtatConnexion();
}
else {
formulaireDeConnexionVue.afficherMessageAlerte(); // Erreur identification
}
break;
}
}
 
*/
 
 
 
 
 
 
}