Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.observation;



import org.tela_botanica.client.interfaces.FournisseurListe;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.modeles.ListeObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeReferentielCommuneAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeReferentielNom;
import org.tela_botanica.client.modeles.ListeReferentielNomAsynchroneDAO;
import org.tela_botanica.client.modeles.NombreObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.ObservationAsynchroneDAO;


public class ObservationModele  {

        
        
        /**
         * Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)
         */
        private static boolean estInstancie = false ;
        
        
        /**
         * La configuration en cours
         */
        private Configuration config = null;

        
        /**
         * Le médiateur associé au modèle
         */
        
        private ObservationMediateur observationMediateur = null ;
        
        
        

        /**
         * Retourne une instance de manière unique
         * @param im le médiateur à associer
         * @return l'instance du modèle
         */
        
        static ObservationModele Instance(ObservationMediateur observationMediateur)
        {
                // si le modèle n'est pas encore instancié
                if(!estInstancie)
                {
                        // on en crée un nouveau
                        estInstancie = true ;
                        return new ObservationModele(observationMediateur);
                }
                else
                {
                        // sinon on renvoit null, interdisant explicitement la création d'un autre exemplaire
                        return null ;
                }
        }

        
        
        private ObservationModele(ObservationMediateur observationMediateur) {
                
                this.observationMediateur=observationMediateur;
                
                config = new Configuration();

                
        }


        
        /**
         * Appelle le DAO asynchrone pour obtenir le nombre d'observation
         * @param r le rafraichissable auxquel on enverra les données
         * @param taillePage 
         */
        public void obtenirNombreObservation(Rafraichissable r) {       
                
                        String motsClesFiltres[][] = observationMediateur.renvoyerFiltres() ;
                        
                        // on rassemble les critères
                        String[][] criteres = {{motsClesFiltres[0][0], motsClesFiltres[0][1]} } ;
                        
                        
                        // on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
                        
                        NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this) ;
                        noaDAO.obtenirNombreObservation(r, observationMediateur.getIdentifiant(), criteres) ;
                                        
        }
        
        
        /**
         * Appelle le DAO asynchrone pour obtenir la liste des images
         * @param r le rafraichissable auxquel on enverra les données
         * @param taillePage 
         */
        public void obtenirListeObservation(Rafraichissable r, int taillePage, int pageEncours) {       
                
                        String motsClesFiltres[][] = observationMediateur.renvoyerFiltres() ;
                        
                        
                        // ensuite on demande la page correspondante avec les mêmes critères
                        String[][] criteres2 = { {"limite" ,""+taillePage },{"numero_page",""+pageEncours}, {motsClesFiltres[0][0], motsClesFiltres[0][1]}} ;
                        
                        // et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
                        
                        ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
                        loaDAO.obtenirListeObservation(r, observationMediateur.getIdentifiant(), criteres2);            
        }
        

        
        public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
                
                ListeReferentielCommuneAsynchroneDAO refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
                refDAO.obtenirListeDonnees(r, critere);
 
        }
        
        
        public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
                
                ListeReferentielNomAsynchroneDAO nomDAO=new ListeReferentielNomAsynchroneDAO(this);
                nomDAO.obtenirListeDonnees(r, critere);
 
        }
        
        
        /**
         *  
         * Lance la creation d'une observation  
         * @param r : la vue demandeuse de donnee
         * @param critere : les criteres de selection
         */
        
        public void ajouterObservation(Rafraichissable r) {
                
                ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
                obsDAO.ajouter();
                        
        }

        
        


        /**
         * Accesseur pour la configuration en cours d'utilisation
         * 
         * @return la configuration
         */
        public Configuration getConfig() {

                return config;
        }


        


        
}