Subversion Repositories eFlore/Applications.cel

Rev

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

package org.tela_botanica.client.vues.observation;


import java.util.HashMap;
import java.util.Iterator;

import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Ontologies;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.Util;
import org.tela_botanica.client.vues.BarrePaginationVue;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;

import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.SortDir;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.SortState;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragDropConfig;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Tool;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.event.GridHeaderListenerAdapter;
import com.gwtext.client.widgets.grid.event.GridListenerAdapter;
import com.gwtext.client.widgets.grid.event.GridRowListenerAdapter;
import com.gwtext.client.widgets.tree.TreeDragData;
import com.gwtext.client.widgets.tree.TreeNode;

/**
 * Liste d'observation composée de ligne d'observation
 * l'interface rafraichissable et l'interface vueListable
 * 
 * @author David Delon 2008
 */
public class ListeObservationVue extends GridPanel implements Rafraichissable,
                VueListable, ListePaginable {

        /**
         * Le médiateur associé à la vue
         */
        private ObservationMediateur    observationMediateur            = null;

        /**
         * Config de colonne
         */
        private ColumnConfig    etatObservation;
        private ColumnConfig    referentielTaxoObservation;
        private ColumnConfig    nomSaisiObservation;
        private ColumnConfig    nomRetenuObservation;
        private ColumnConfig    familleObservation;
        private ColumnConfig    lieuObservation;
        private ColumnConfig    altitudeObservation;
        private ColumnConfig    dateObservation;
        private ColumnConfig    ordreObservation;
        private ColumnConfig    abondanceObservation;
        private ColumnConfig    certitudeObservation;
        private ColumnModel             modeleColonnes;

        /**
         * Store qui contient les données à afficher
         */
        private Store                   st                              = null;
        /**
         * Barre de pagination
         */
        private BarrePaginationVue bt = null ;
        /**
         * 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 ListeObservation cacheListeObservation = null;
        
        private Tool exporterObservations = null ;
        
        private final int KEY_ENTER = 13;
        
        private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION";


        private boolean tailleInitialisee = false ;

        private ColumnConfig phenologieObservation;

        private SortDir directionTri;

        private String champTri;
        
        private boolean triActif;
        
        /**
         * Constructeur sans arguments (privé car ne doit pas être utilisé)
         */
        @SuppressWarnings("unused")
        private ListeObservationVue()
        {
                super() ;
        }
        
        /**
         * Constructeur avec argument
         * @param im le médiateur à associer
         */
        public ListeObservationVue(ObservationMediateur obs) {          
                
                this.observationMediateur = obs;
                
                setId("x-list-obs");
                
                setHeader(true);  
                // on place la barre de pagination
                bt = new BarrePaginationVue(this);              
                bt.setLabelElement("Observations");
                bt.setTaillePageParDefaut(20);
                bt.setIntervallesPages(new String[] {"1000","400","200","100","50","20","10"}) ;
                
                Toolbar barreActions = new Toolbar();
                ToolbarButton publier = new ToolbarButton("Rendre publiques");
                publier.addListener(new ButtonListenerAdapter() {
                        @Override
                        public void onClick(Button b, EventObject e) {
                                observationMediateur.transmettreObservations(true);
                        }
                });
                
                ToolbarButton privatiser = new ToolbarButton("Rendre privées");
                privatiser.addListener(new ButtonListenerAdapter() {
                        @Override
                        public void onClick(Button b, EventObject e) {
                                observationMediateur.transmettreObservations(false);
                        }
                });
                
                ToolbarButton supprimer = new ToolbarButton("Supprimer");
                supprimer.addListener(new ButtonListenerAdapter() {
                        @Override
                        public void onClick(Button b, EventObject e) {
                                observationMediateur.supprimerObservations();
                        }
                });
                
                ToolbarButton importer = new ToolbarButton("Importer");
                importer.addListener(new ButtonListenerAdapter() {
                        @Override
                        public void onClick(Button b, EventObject e) {
                                observationMediateur.afficherFormulaireImportObservation();
                        }
                });
                
                ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>");
                ToolbarTextItem exporterFull = new ToolbarTextItem("<a href=\"#\" id=\"lienExportFull\" title=\"Export des noms communs, des champs étendus, des données baseflor et des syntaxon baseveg\"> Export Étendu </a>");
                ToolbarTextItem exporterPDF = new ToolbarTextItem("<a href=\"#\" id=\"lienExportPDF\" title=\"Génération d'étiquettes au format PDF pour la sélection\"> Étiquettes </a>");
                
                barreActions.addButton(publier);
                barreActions.addButton(privatiser);
                barreActions.addSpacer();
                barreActions.addButton(supprimer);
                barreActions.addSpacer();
                barreActions.addButton(importer);
                barreActions.addSpacer();
                barreActions.addItem(exporter);
                barreActions.addItem(exporterFull);
                barreActions.addItem(exporterPDF);
                
                this.setTopToolbar(barreActions) ;
                this.setBottomToolbar(bt);
                
                this.setCollapsible(true);
                this.setTitleCollapse(true);

                this.setTitle("Observations") ;
                
                modeleColonnes = new ColumnModel(getConfigColonnes());
                
                this.setColumnModel(modeleColonnes);
                
                this.setAutoScroll(true);
                this.setEnableColumnResize(true);
                
                // creation du store            
                RecordDef rd = new RecordDef(getDefinitionChamps());
                st = new Store(rd);

                // on associe le store
                
                this.setStore(st);
                this.getView().setAutoFill(true);
                this.getView().setForceFit(true) ;
                                
                // on crée un masque de chargement qui s'affichera lors des mises à jour
                this.setLoadMask("Chargement");
        
                // on ajoute les listeners
                ajouterListeners();
                
                configDragAndDrop();

        }
        
        private ColumnConfig[] getConfigColonnes() {
                // on construit le modèle de colonnes
                // Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir) 
                Renderer colRend = new Renderer() {

                        @Override
                        public String render(Object value, CellMetadata cellMetadata,
                                        Record record, int rowIndex, int colNum, Store store) {
                                
                                String valeur = "";
                                if(value != null && !value.equals("null") && !value.equals("000null") && !value.equals("0000-00-00 00:00:00")) {                        
                                        valeur = value.toString() ;
                                }
                                return valeur;
                        }
                } ;
                
                Renderer dateRend = new Renderer() {

                        @Override
                        public String render(Object value, CellMetadata cellMetadata,
                                        Record record, int rowIndex, int colNum, Store store) {
                                
                                if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {
                                
                                        return "" ;
                                }       
                                else
                                {
                                        String dateEntiere = value.toString() ;
                                        String[] dateEtHeure = dateEntiere.split(" ", 2);
                                        if(verifierFormatDate(dateEtHeure[0])) {
                                                String[] dateFormateeTab = dateEtHeure[0].split("-",3);
                                                return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ;
                                        }
                                }
                                
                                return value.toString() ;
                        }
                        
                } ;
                
                etatObservation = new ColumnConfig("Transmis", "etat_observation", 20, true, new Renderer() {

                        @Override
                        public String render(Object value, CellMetadata cellMetadata,
                                        Record record, int rowIndex, int colNum, Store store) {
                                if(value.equals("1"))
                                {
                                        return "<img src=\"tela.png\"/></img>" ;
                                }
                                else
                                {
                                        return "" ;
                                }
                        }
                        
                });             
                
                referentielTaxoObservation = new ColumnConfig("Référentiel", "referentiel_taxo_observation", 15, true, colRend);
                nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 130, true, colRend);
                nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 130, true, colRend);
                familleObservation = new ColumnConfig("Famille", "famille_observation", 50, true, colRend);
                lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 130, true, colRend);
                altitudeObservation = new ColumnConfig("Alt", "altitude_observation", 10, true, colRend);
                dateObservation = new ColumnConfig("Date", "date_observation", 70, true, dateRend);
                abondanceObservation = new ColumnConfig("Abondance", "abondance", 50, true, colRend);
                certitudeObservation = new ColumnConfig("Identification", "certitude", 50, true, new Renderer() {
                        @Override
                        public String render(Object value, CellMetadata cellMetadata,
                                        Record record, int rowIndex, int colNum, Store store) {
                                return Ontologies.getCorrespondanceCertitude(record.getAsString("certitude"));
                        }
                        
                });
                phenologieObservation = new ColumnConfig("Phénologie", "phenologie", 40, true, colRend);       
                ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 70, true, colRend);           
                ColumnConfig[] cm = {etatObservation, referentielTaxoObservation, 
                                                         nomSaisiObservation, certitudeObservation, 
                                                         nomRetenuObservation, familleObservation,
                                                         abondanceObservation, phenologieObservation,
                                                         lieuObservation, altitudeObservation,
                                                         dateObservation, ordreObservation};
        
                return cm;
        }


        /**
         * Ajoute les listeners pour la gestion des évènements
         */
        private void ajouterListeners() {
                        
                this.addGridHeaderListener(new GridHeaderListenerAdapter() {            
                        @Override
                        public void onHeaderClick(GridPanel grid, int colIndex, EventObject e) {
                                triActif = true;
                                Timer t = new Timer() {
                                        
                                        @Override
                                        public void run() {
                                                enregistrerEtatTri();
                                                observationMediateur.obtenirListeObservation();
                                        }
                                };
                                t.schedule(200);
                        }
                });
                
                this.addGridRowListener(new GridRowListenerAdapter() {
                        
                        // gestion du clic sur une ligne
                        @Override
                        public void onRowClick(GridPanel grid, int rowIndex,
                                        EventObject e) {
                                // on notifie le médiateur et on lui passe le numéro de ligne
                                
                        
                                Record rd = st.getAt(rowIndex);
                                
                                String ordreObservation = rd.getAsString("ordre_observation") ;
                                observationMediateur.onClicListeObservation(rowIndex,ordreObservation);
                                
                        }

                        // gestion du clic droit
                        @Override
                        public void onRowContextMenu(GridPanel grid, int rowIndex,
                                        EventObject e) {
                                // on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu
                                e.stopEvent() ;
                                // on notifie le médiateur en lui passant l'évenement
                                observationMediateur.montrerContextMenu(e);
                        }

                        // gestion du double clic
                        @Override
                        public void onRowDblClick(GridPanel grid, int rowIndex,
                                        EventObject e) {
                                // on notifie le médiateur en lui passant le numéro de ligne
                                observationMediateur.doubleClicListeObservation(rowIndex);
                        }
                        
                });
                
                this.addGridListener(new GridListenerAdapter() {
                        @Override
                        public void onKeyPress(EventObject e) {
                                if(e.getKey() == KEY_ENTER) {
                                        Record rd = getSelectionModel().getSelected();
                                        int rowIndex = st.indexOf(rd);
                                        String ordreObservation = rd.getAsString("ordre_observation") ;
                                        observationMediateur.onClicListeObservation(rowIndex, ordreObservation);
                                }
                        }
                });
                
                this.addListener(new PanelListenerAdapter() {
                        @Override
                        public void onRender(Component c) {
                                
                                ExtElement lienExport = Ext.get("lienExport") ;
                                lienExport.addListener("click", new EventCallback() {
                                        @Override
                                        public void execute(EventObject e) {
                                                observationMediateur.exporterObservations("xls", "standard");
                                        }
                                });

                                ExtElement lienExportFull = Ext.get("lienExportFull") ;
                                lienExportFull.addListener("click", new EventCallback() {
                                        @Override
                                        public void execute(EventObject e) {
                                                observationMediateur.exporterObservations("xls", "standard,avance,etendu,baseflor");
                                        }
                                });

                                ExtElement lienExportPDF = Ext.get("lienExportPDF") ;
                                lienExportPDF.addListener("click", new EventCallback() {
                                        @Override
                                        public void execute(EventObject e) {
                                                observationMediateur.exporterObservationsPDF();
                                        }
                                });
                        }
                });
                
                this.addListener(new PanelListenerAdapter() {
                        @Override
                        public void onBodyResize(Panel panel, java.lang.String width, java.lang.String height) {
                                doLayout();
                        }
                });
        }
        
        /**
         * Configure le drag 'n drop pour la liste
         */
        private void configDragAndDrop()
        {

                setDdGroup("ObsMotsClesGroup");
                setEnableDragDrop(true);
                setDragDropText("Glissez les observations sélectionnées sur un projet pour les lier");
                // on fabrique la nouvelle configuration
                // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
                DropTargetConfig dtc = new DropTargetConfig();
                dtc.setdDdGroup("ObsMotsClesGroup");
                dtc.setTarget(true);
                
                DragDropConfig ddc = new DragDropConfig();

                //La drop target permet de gérer l'évenement onDrop sur l'élement courant
                @SuppressWarnings("unused")
                DropTarget tg = new DropTarget(this, dtc)
                {
                        @Override
                        public boolean notifyDrop(DragSource source, EventObject e, DragData data){     
                                
                                // si on reçoit des données provenant d'un arbre
                                // on les convertit 
                                if(data instanceof TreeDragData)  {
                                TreeDragData tdd = (TreeDragData)data ;
                                
                                TreeNode treeNode = tdd.getTreeNode();  
                                String idMc = treeNode.getId();  
                                
                                int index = getView().findRowIndex(e);
                                if(index < 0) {
                                        return true;
                                }
                                
                                Record obsRd = getStore().getRecordAt(index);
                                if(obsRd == null) {
                                        return true;
                                }
                                
                                String ordreObs = obsRd.getAsString("ordre_observation");
                                
                                if(ordreObs != null) {
                                        observationMediateur.gererDDMotCleSurObs(ordreObs, idMc);
                                        return true ;
                                } else {
                                        return true;
                                }
                                }
                        return true;
                        }
                        
                        @Override
                        public String notifyOver(DragSource source, EventObject e, DragData data){
                                
                                if(data instanceof TreeDragData)  {
                                TreeDragData tdd = (TreeDragData)data ;
                                
                                TreeNode treeNode = tdd.getTreeNode();  
                                String idMc = treeNode.getId();  
                                
                                int index = getView().findRowIndex(e);
                                if(index < 0) {
                                        return "x-dd-drop-nodrop";
                                }
                                
                                Record obsRd = getStore().getRecordAt(index);
                                
                                if(obsRd == null) {
                                        return "x-dd-drop-nodrop";
                                }
                                
                                String ordreObs = obsRd.getAsString("ordre_observation");
                                
                                if(ordreObs != null) {
                                        return observationMediateur.gererOverDDMotCleSurObs(ordreObs, idMc);
                                }
                                }
                                
                                return "x-dd-drop-nodrop";
                        }
                };
        }

        /**
         * Méthode héritée de l'interface VueListable
         * Sélectionne les observations  dans la liste suivant les identifiants donnés en paramètres
         */
        @Override
        public String[] getIdSelectionnees() {
                
                Record[] selection = this.getSelectionModel().getSelections();
                int taille = selection.length;
                String id_selection[] = new String[taille];

                for (int i = 0; i < selection.length; i++) {

                        id_selection[i] = selection[i].getAsString("ordre_observation");
                }

                return id_selection;
        }
        

        
        /**
         * Sélectionne des enregistrements donné 
         * @param sel un tableau d'enregistrement à selectionner
         */
        public void selectionnerEnregistrements(Record[] sel) {

                        getSelectionModel().clearSelections();
                        getSelectionModel().selectRecords(sel);
                
        }
        
        /**
         * Accesseur pour la toolbar de pagination
         * @return la toolbar de pagination
         */
        public BarrePaginationVue getToolBarVue()
        {
                return bt ;
        }


        /**
         * Recherche l'élement actuellement affiché et affiche son message de chargement
         */
        public void masquerChargement()
        {
                ExtElement masked = Ext.get(getId()) ;

                if (masked!=null) {
                        masked.mask("Chargement") ;
                }
        }
        
        /**
         * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
         */
        public void demasquerChargement()
        {
                ExtElement masked = Ext.get(getId()) ;
                
                if (masked!=null) {
                        masked.unmask() ;
                }
        }
        
        /**
         * Méthode héritée de l'interface rafraichissable
         * @param nouvelleDonnees les nouvelles données
         * @param repandreRafraichissement le booleen de notification du rafraichissement
         */
        @Override
        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()][13];
                                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=data.get(it.next());
                                        
                                        observationData[i][0] = obs.getTransmis();
                                        observationData[i][1] = obs.getCodeCourtReferentielTaxo();
                                        observationData[i][2] = obs.getNomSaisi();
                                        observationData[i][3] = obs.getCertitude();
                                        observationData[i][4] = obs.getNomRetenu();
                                        observationData[i][5] = obs.getFamille();
                                        observationData[i][6] = obs.getAbondance();
                                        observationData[i][7] = obs.getPhenologie();
                                        observationData[i][8] = Util.formaterLieu(obs, modeleLieu);
                                        observationData[i][9] = formaterAltitude(obs.getAltitude());
                                        observationData[i][10] = obs.getDate();
                                        observationData[i][11] = obs.getNumeroOrdre();          
                                        observationData[i][12] = obs.getNumeroNomenclaturalSaisi();
                                                                        
                                        i++ ;
                                }
                
                                RecordDef rd = new RecordDef(getDefinitionChamps());
                                
                                final MemoryProxy dataProxy = new MemoryProxy(observationData);
                                final ArrayReader reader = new ArrayReader(rd);
                
                                final Store observationStore = new Store(dataProxy, reader);
                                
                                st = observationStore ;
                                st.load() ;
                                                                        
                                // et on reconfigure et rafraichit la vue
                                this.reconfigure(st, this.getColumnModel());
                                demasquerChargement();
                            cacheListeObservation=data;
                                observationMediateur.onRafraichissementListeObservations();     
                }
                
                // 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]) ;
                        
                        if(nbElements > 0) {
                                masquerChargement();
                                observationMediateur.obtenirListeObservation(this);
                        } else {
                                this.rafraichir(new ListeObservation(0), false);
                        }
                }
                
                
                // si l'on a reçu une Observation 
                if(nouvelleDonnees instanceof Observation) {
                        // la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri
                        // on l'enregistre donc avant suppression 
                        enregistrerEtatTri();
                        Observation obs= (Observation) nouvelleDonnees;
                        if (obs.getNumeroOrdre()==null) { 
                                
                                // Nouvelle observation
                                // On affiche la dernière page
                                pageEncours = pageMax ;
                                masquerChargement();
        
                                observationMediateur.obtenirNombreObservation();
                        
                        }
                        else { // Modification d'une observation
                                        
                                masquerChargement();
                                observationMediateur.obtenirNombreObservation();                
                        }
                }
                
                // Si on a effectué une suppression
                if(nouvelleDonnees instanceof String)
                {
                        // la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri
                        // on l'enregistre donc avant suppression 
                        enregistrerEtatTri();
                        observationMediateur.obtenirNombreObservation() ;
                }
                
                if(!getTailleInitialisee()) {
                        if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) {
                                doLayout();
                                setTailleInitialisee();
                        }
                }
                
                // réaffectation du tri courant si nécessaire
                if(directionTri != null && champTri != null) {
                        st.sort(champTri, directionTri);
                }
        }
        
        private String formaterAltitude(String alt) {
                String alfFmt = Util.formaterNombre(alt);
                if(!alfFmt.isEmpty() && !Util.estZero(alfFmt)) {
                        alfFmt = alfFmt+" m.";
                }
                return alfFmt;
        }
        
        private FieldDef[] getDefinitionChamps() {
                // creation du store qui les contient
                FieldDef defEtatObservation = new StringFieldDef("etat_observation");
                FieldDef defRefTaxObservation = new StringFieldDef("referentiel_taxo_observation");
                FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
                FieldDef defCertitudeObservation = new StringFieldDef("certitude");
                FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
                FieldDef defFamilleObservation = new StringFieldDef("famille_observation");
                FieldDef defAbondanceObservation = new StringFieldDef("abondance");
                FieldDef defPhenologieObservation = new StringFieldDef("phenologie");
                FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
                FieldDef defAltObservation = new StringFieldDef("altitude_observation");
                FieldDef defDateObservation = new StringFieldDef("date_observation");
                FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");
                
                // Non affiches :
                FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");

                FieldDef[] defTab = {defEtatObservation, defRefTaxObservation,defNomSaisiObservation, defCertitudeObservation, defNomRetenuObservation, defFamilleObservation, defAbondanceObservation,
                                defPhenologieObservation, defLieuObservation, defAltObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation };
                
                return defTab;
        }
        
        
        // GESTION DE LA PAGINATION
        public ListeObservation getCacheListeObservation() {
                return cacheListeObservation;
        }

        /**
         * 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) arrondi à l'entier superieur
                double nPage = (1.0*nbElements)/(1.0*taillePage) ; 
                double nPageRound = Math.ceil(nPage) ;
                Double nPageInt = new Double(nPageRound) ;
                
                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) ;
                
                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
         */
        @Override
        public void changerNumeroPage(int pageCourante) {
                pageEncours = pageCourante ;
                masquerChargement();
                
                enregistrerEtatTri();
                // On lance le chargerment des observations
                observationMediateur.obtenirNombreObservation();
                getToolBarVue().changerPageCourante(pageCourante);      
        }
        
        
        /**
         * Appelle le modèle pour qu'il change la taille de page utilisée
         * @param nouvelleTaillePage la nouvelle taille de page
         */
        @Override
        public void changerTaillePage(int nouvelleTaillePage) {
        
                taillePage = nouvelleTaillePage ;
                pageEncours = calculerPageCourante(nbElements) ;
                
                enregistrerEtatTri();

                masquerChargement();

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

        
        /**
         * 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} ;
                getToolBarVue().rafraichir(pages, false) ;
        }
        
        /**
         * Renvoie la taille de page en cours d'utilisation
         * @return la taille de page
         */
        public int getTaillePage() {
                
                return taillePage;
        }
        
        /**
         * Renvoie le numéro de la page encours (attention on commence à 0)
         * @return le numéro de la page en cours
         */
        public int getPageEncours() {
                
                return pageEncours;
        }
        
        private void enregistrerEtatTri() {
                if(triActif) {
                        this.directionTri = st.getSortState().getDirection();
                        this.champTri = st.getSortState().getField();
                }
        }
        
        public void afficherFiltres(String[][] filtresEnCours) {
                
                String texteFiltresEnCours = "";
                
                for(int i = 0; i < filtresEnCours.length; i++) {
                        if(Util.filtreValide(filtresEnCours[i])) {
                                
                                if(!texteFiltresEnCours.equals("")) {
                                        texteFiltresEnCours += " - ";
                                }
                                
                                texteFiltresEnCours += "<span class=\"affichage_filtre\">"+
                                                                                        transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+
                                                                           " <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_obs_"+filtresEnCours[i][0]+"\" />"+
                                                                                "</span>";
                        }
                }
                
                if(!texteFiltresEnCours.equals("")) {
                        texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>";
                }
                
                this.setTitle("Observations"+texteFiltresEnCours) ;
                
                for(int i = 0; i < filtresEnCours.length; i++) {
                        
                        if(Util.filtreValide(filtresEnCours[i])) {
                                if(Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]) != null) {
                                        
                                        Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]).addListener("click", new EventCallback() {
                                                
                                                @Override
                                                public void execute(EventObject e) {
                                                        e.stopEvent();
                                                        observationMediateur.viderFiltre(e.getTarget().getAttribute("rel"));
                                                }
                                                
                                        });
                                }
                        }
                }
        }
        
        private String transformerNomFiltre(String nomFiltre) {
                
                if(nomFiltre.equals("departement")) {
                        nomFiltre = "departement";
                }
                
                if(nomFiltre.equals("commune")) {
                        nomFiltre = "commune";
                }
                
                if(nomFiltre.equals("nom_taxon")) {
                        nomFiltre = "recherche";
                }
                
                if(nomFiltre.equals("id_mots_cles")) {
                        nomFiltre = "projets";
                }
                
                return nomFiltre;
                
        }
        
        private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) {
                
                String valeurFiltreTransformee = valeurFiltre;
                
                if(nomFiltre.equals("id_mots_cles")) {
                        
                        String[] tabMotsCles = valeurFiltre.split(";");
                        String[] tabMotsClesTexte = observationMediateur.obtenirTexteMotsCles(tabMotsCles);
                        
                        if(tabMotsClesTexte.length > 1) {
                                valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte);
                        } else {
                                valeurFiltreTransformee = tabMotsClesTexte[0];
                        }
                }
                
                if(nomFiltre.equals("mois")) {
                        valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre));
                }
                
                valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("000null", "inconnue");
                valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("null", "inconnue");
                valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("NULL", "inconnue");

                return valeurFiltreTransformee;
                
        }

        public void raz() {             
                RecordDef rd = new RecordDef(getDefinitionChamps());
                st = new Store(rd);
                // on associe le store
                this.setStore(st);      
        }
        
        public boolean verifierFormatDate(String date) {
                
                String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ;
                if(date.matches(regex) && !date.equals("0000-00-00")) {
                        return true ;
                }
                else {
                        return false;
                }
        }
        
        public boolean getTailleInitialisee() {
                return tailleInitialisee ;
        }
        
        public void setTailleInitialisee() {
                tailleInitialisee = true;
        }

        public String renvoyerTri() {
                String tri = "ordre";
                if(triActif) {
                        HashMap<String, String> corr = Ontologies.getCorrespondanceGrilleObservationChampsTri();
                        if(corr.containsKey(champTri)) {
                                tri = corr.get(champTri);
                        }
                }
                return tri;
        }

        public String renvoyerDirectionTri() {
                try {
                        return (triActif) ? directionTri.getDirection() : "ASC";
                } catch (Exception e) {
                        return "ASC";
                }
        }
}