Subversion Repositories eFlore/Archives.cel-v2

Rev

Rev 9 | Blame | Compare with Previous | Last modification | View Log | RSS feed

package org.tela_botanica.client.observation;


import java.util.Iterator;
import org.tela_botanica.client.CarnetEnLigneMediateur;
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.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;

/**
 * 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 ;  
        
        /** 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 ;
        
        

        /**
         * 
         * 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 ;
        
        
        /**
         * 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() ;

                
                // 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);

                
                //panneauListeObservation.setLayout(new FitLayout());
                //panneauListeObservation.setSize(600,600);
                //panneauListeObservation.add(listeObservation);
                
                
                // 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);
        
                panneauPrincipalObservation.add(listeObservation);
                
        
        

        }


        /**
         * 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 ;
                                
                        }
        }
        
        
        
        /**
         * envoie au modèle une demande de mise a jour
         */


        public void obtenirNombreObservation() {
                
        
                        listeObservation.masquerChargement();
                    observationModele.obtenirNombreObservation(this) ;
                
        }
        
        /**
         * envoie au modèle une demande de mise a jour
         */


        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;
        }
        
        
        
        // 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();
                }
        }
        
        
        /**
         * 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
         */
        public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement) 
        {
                                
                int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
                listeObservation.getToolBarVue().rafraichir(pages, false) ;
                
        }
        
        
        
        /**
         * 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 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
                
                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() ; 
        }

        
        /**
         * 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 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) ;
                
                // on arrondit au supérieur
                double nPageRound = Math.ceil(nPageCourante) ;
                Double nPageInt = new Double(nPageRound) ;
                
                // on convertit en entier
                return Math.abs(nPageInt.intValue()) ; 
        }
        

        /**
         * Appelle le modèle pour lui demander les données d'une page à afficher
         * @param pageCourante le numéro de page à affciher
         */
        public void changerNumeroPage(int pageCourante) {
                
                
                
                pageEncours = pageCourante ;
                
                // On lance le chargerment des observations
                obtenirNombreObservation();
                
                listeObservation.getToolBarVue().changerPageCourante(pageCourante);
                
        }
        
        
        /**
         * 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)
        {
        
                taillePage = nouvelleTaillePage ;
                pageEncours = calculerPageCourante(nbElements) ;

                //      On lance le chargerment des observations
                obtenirNombreObservation();
                
                
                // et on met à jour la taille de page dans les barres d'outils
                listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
                
                
        }


        // Retourne le fournisseur de donnee en referentiel Commune. doit posseder la methode obtenirListeDonnees()
        
        public FournisseurListe obtenirFournisseurReferentielCommune() {
                
                return observationModele.obtenirFournisseurReferentielCommune() ;

                
        }


        

        
        
}