Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.observation;


//TODO : normaliser les noms de methodes (obtenir, ajouter ...)

import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.modeles.ExportObservationsDAO;
import org.tela_botanica.client.modeles.ImageGeneriqueVueAsynchroneDAO;
import org.tela_botanica.client.modeles.ImageInformationRepartitionAsynchroneDAO;
import org.tela_botanica.client.modeles.LienImageAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeDateObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeReferentielCommuneAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeReferentielNomAsynchroneDAO;
import org.tela_botanica.client.modeles.MotsClesObsAsynchronesDAO;
import org.tela_botanica.client.modeles.NomRetenuAsynchroneDao;
import org.tela_botanica.client.modeles.NombreObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.Observation;
import org.tela_botanica.client.modeles.ObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.TransmissionObservationAsynchroneDAO;


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 ;
        
        private static ObservationModele thisModele = null ;
        
        
        
        
        /**
         * La configuration en cours
         */
        private Configuration config = null;

        
        /**
         * Le médiateur associé au modèle
         */
        
        private ObservationMediateur observationMediateur = null ;
        
        
        
        /**
         * DAO dont le resultat peut etre mis en cache 
         * 
         */
        
        private ListeReferentielNomAsynchroneDAO nomDAO=null;
        private ListeReferentielCommuneAsynchroneDAO refDAO=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 ;
                        thisModele = new ObservationModele(observationMediateur);
                }
                return thisModele ;
        }

        
        
        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 filtrage 
         * @param taillePage 
         */
        public void obtenirNombreObservation(Rafraichissable r) {       
        
                String[][] criteres = {{"",""}} ;               
                        criteres = observationMediateur.renvoyerFiltres() ;                     
                        // on rassemble les critères
                        
                        
                        // 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[][] criteres = {{"",""}} ;
                                criteres = observationMediateur.renvoyerFiltres() ;                     
                                // on rassemble les critères
                        
                        
                        // ensuite on demande la page correspondante avec les mêmes critères
                        String[][] criteres2 = new String[criteres.length+2][2] ;
                        
                        criteres2[0][0] = "limite" ;
                        criteres2[0][1] = ""+taillePage ;
                        criteres2[1][0] = "numero_page" ;
                        criteres2[1][1] = ""+pageEncours ;
                        for(int i = 0 ; i < criteres.length ; i++)
                        {
                                criteres2[i+2][0] = criteres[i][0] ; 
                                criteres2[i+2][1] = criteres[i][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);            
        }
        

        /**
         * Obtenir une liste de commune 
         * @param r
         * @param critere
         */
        
        public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
                
                if (refDAO==null) {
                        refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
                }
                ListeReferentielCommuneAsynchroneDAO refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
                refDAO.obtenirListeDonnees(r, critere);
 
        }
        
        /**
         * Obtenir une liste de nom scientifique de plante
         * @param r
         * @param critere
         */
        
        public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
                
                if (nomDAO==null) {
                        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, Observation obs) {
                
                ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
                obsDAO.ajouter(r, observationMediateur.getIdentifiant(), obs);
                        
        }

        /**
         *  
         * Lance la creation d'une observation  
         * @param r : la vue demandeuse de donnee
         * @param critere : les criteres de selection
         */
        
        public void modifierObservation(Rafraichissable r, Observation obs) {
                
                ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
                obsDAO.modifier(r, observationMediateur.getIdentifiant(), obs);
                        
        }
        
        public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
                
                ObservationAsynchroneDAO obsDao = new ObservationAsynchroneDAO(this) ;
                obsDao.supprimer(r,observationMediateur.getIdentifiant(),numeroOrdre) ;
                
                
        }
        
        


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

                return config;
        }

        
        /**
         * Obtenir des informations de repartition relative a un numero nomenclatural
         * @param r
         * @param numeroNomenclaturalSaisiObservation
         */


        public void obtenirImageInformationRepartition( Rafraichissable r,String numeroNomenclaturalSaisiObservation) {
                
                ImageInformationRepartitionAsynchroneDAO repDAO=new ImageInformationRepartitionAsynchroneDAO(this);
                repDAO.obtenirURLImage(r, numeroNomenclaturalSaisiObservation);
                
                
        }

        /**
         * Obtenir une image generique associee a un numero nomenclatural
         * @param r
         * @param numeroNomenclaturalSaisiObservation
         */

        public void obtenirImageGenerique( Rafraichissable r,String numeroNomenclaturalSaisiObservation) {
                
                ImageGeneriqueVueAsynchroneDAO imgDAO=new ImageGeneriqueVueAsynchroneDAO(this);
                imgDAO.obtenirURLImage(r, numeroNomenclaturalSaisiObservation);
                
                
        }


        /**
         * Obtenir la liste de l'ensemble des entites geographiques associes aux observation d'un utilisateur 
         * @param r
         */

        public void obtenirListeEntiteGeographique(Rafraichissable r) {

            ListeEntiteGeographiqueObservationAsynchroneDAO entDAO = new ListeEntiteGeographiqueObservationAsynchroneDAO(this);
            entDAO.obtenirListeEntitesGeographiques(r, observationMediateur.getIdentifiant());

        }



        public void obtenirDatesObservation(
                        Rafraichissable r) {
            ListeDateObservationAsynchroneDAO ldoDAO = new ListeDateObservationAsynchroneDAO(this);
            ldoDAO.obtenirListeDate(r, observationMediateur.getIdentifiant());
                
        }



        public void obtenirLiaisonImage(Rafraichissable r,
                        String ordreObservation) {
                
                LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ;
                liaDAO.obtenirLiaisonsObservationsImages(r, ordreObservation,observationMediateur.getIdentifiant()) ;
                
        }



        public void exporterObservations() {
                
                String[][] criteres = {{"",""}} ;               
                criteres = observationMediateur.renvoyerFiltres() ;                     
                // on rassemble les critères
                
                
                // on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
                
                ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
                exoDAO.exporterObservations(observationMediateur.getIdentifiant(), criteres) ;
                                
                
        }



        public void supprimerLiaisonImages(String idImg, String idObs) {
                
                LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
                lienDAO.supprimerLienImageObservation(idImg, idObs) ;           
                
        }



        public String getIdentifiant() {
                
                return observationMediateur.getIdentifiant() ;
        }



        public void supprimerListeObservation(Rafraichissable r,
                        String numObs) {
                ListeObservationAsynchroneDAO lioaDAO = new ListeObservationAsynchroneDAO(this);
                lioaDAO.supprimerListeObservation(r, observationMediateur.getIdentifiant(), numObs);
                
        }



        public void transmettreListeObservation(
                        Rafraichissable r, String numObsapl, boolean publier) {
                TransmissionObservationAsynchroneDAO toaDAO = new TransmissionObservationAsynchroneDAO(this);
                toaDAO.transmettreObservations(r, observationMediateur.getIdentifiant(), numObsapl, publier);
                
        }



        public void obtenirNuageMotsCles(Rafraichissable r) {
                
                MotsClesObsAsynchronesDAO mcoaDAO = new MotsClesObsAsynchronesDAO(this);
                mcoaDAO.obtenirMotsClesObservations(r);
                
        }



        public void ajouterMotsCles(Rafraichissable r,
                        String numObsApl, String motsAAjouter) {
                
                MotsClesObsAsynchronesDAO moadDAO = new MotsClesObsAsynchronesDAO(this);
                moadDAO.ajouterMotsCles(r,numObsApl,motsAAjouter);
                
        }



        public void analyserHistorique(Rafraichissable r,String anum) {
                
                NomRetenuAsynchroneDao nraDAO = new NomRetenuAsynchroneDao(this);
                nraDAO.obtenirNomRetenu(r, anum);
                
        }



        public void importerObservations() {
                ImportObservationAsynchroneDAO ioDAO = new ImportObservationAsynchroneDAO(this);
                ioDAO.importerObservations();
                
        }
        
}