Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.observation;


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

import java.util.HashMap;

import org.tela_botanica.client.i18n.Msg;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.dao.ExportObservationsDAO;
import org.tela_botanica.client.modeles.dao.ImageGeneriqueVueAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ImportObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.InformationLocaliteDAO;
import org.tela_botanica.client.modeles.dao.LiaisonMotsClesObsAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeDateObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeEntiteGeographiqueObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeReferentielLocaliteAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NomRetenuAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.TransmissionObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
import org.tela_botanica.client.util.MotsClesUtilitaire;

import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.user.client.Window;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.tree.TreeNode;


public class ObservationModele implements Rafraichissable {

        /**
         * 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 ;
        
        /**
         * La liste des mots clés en cours 
         */
        private HashMap<String, String> motsCles = new HashMap<String, String>(0);      
        private Tree arbreMotsCles = new Tree() ;
        
        /**
         * La liste des observations affichées en cours (verifier utilité)
         */
        private ListeObservation cacheObservation = new ListeObservation(0) ;
        
        /**
         * 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, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres) ;
                                        
        }
        
        
        public void obtenirListeObservation(Rafraichissable r) {
                obtenirListeObservation(r,observationMediateur.getTaillePage(),observationMediateur.getPageEnCours());
        }
        
        /**
         * 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+4][2] ;
                        
                        criteres2[0][0] = "limite" ;
                        criteres2[0][1] = ""+taillePage ;
                        criteres2[1][0] = "numero_page" ;
                        criteres2[1][1] = ""+pageEncours ;
                        criteres2[2][0] = "tri" ;
                        criteres2[2][1] = ""+observationMediateur.renvoyerTri();
                        criteres2[3][0] = "tri_dir";
                        criteres2[3][1] = ""+observationMediateur.renvoyerDirectionTri() ;
                        
                        for(int i = 0 ; i < criteres.length ; i++)
                        {
                                criteres2[i+4][0] = criteres[i][0] ; 
                                criteres2[i+4][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, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres2);            
        }
        
        /**
         *  
         * 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, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), 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, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);         
        }
        
        public void modifierObservationEnMasse(
                        Rafraichissable r, Observation obs) {
                ListeObservationAsynchroneDAO liObsDAO=new ListeObservationAsynchroneDAO(this);
                liObsDAO.modifierEnMasse(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);        
        }

        public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
                
                ObservationAsynchroneDAO obsDao = new ObservationAsynchroneDAO(this) ;
                obsDao.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(),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 referentielTaxo, String numeroNomenclaturalSaisiObservation) {
                
                ImageInformationRepartitionAsynchroneDAO repDAO= new ImageInformationRepartitionAsynchroneDAO(this);
                repDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation);
                
                
        }

        /**
         * Obtenir une image generique associee a un numero nomenclatural
         * @param r
         * @param numeroNomenclaturalSaisiObservation
         */
        public void obtenirImageGenerique( Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {             
                ImageGeneriqueVueAsynchroneDAO imgDAO= new ImageGeneriqueVueAsynchroneDAO(this);
                imgDAO.obtenirURLImage(r, referentielTaxo, 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, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
        }



        public void obtenirDatesObservation(
                        Rafraichissable r) {
            ListeDateObservationAsynchroneDAO ldoDAO = new ListeDateObservationAsynchroneDAO(this);
            ldoDAO.obtenirListeDate(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());  
        }



        public void obtenirLiaisonImage(Rafraichissable r, String idObservation) {      
                LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ;
                liaDAO.obtenirLiaisonsObservationsImages(r, idObservation,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()) ;
        }



        public void exporterObservations(String format, String groupes) {
                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(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres, format, groupes) ;
        }

        public void exporterObservationsPDF(String[] ordres) {
                String[][] criteres = {{"",""}} ;               
                criteres = observationMediateur.renvoyerFiltres();
                String ids = "";
                for (int j = 0; j < ordres.length; j++) {
                        ids += getIdPourOrdreObs(ordres[j]) + ",";
                }

                String[] fmt = {"obsids", ids};
                String[][] tous_criteres = new String[criteres.length + 1][];
                System.arraycopy(criteres, 0, tous_criteres, 0, criteres.length);
                tous_criteres[tous_criteres.length - 1] = fmt;

                ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
                exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), tous_criteres, "pdf", "standard") ;
        }



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

        public void supprimerListeObservation(Rafraichissable r, String numObs) {
                ListeObservationAsynchroneDAO lioaDAO = new ListeObservationAsynchroneDAO(this);
                lioaDAO.supprimerListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObs);    
        }

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

        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();   
        }



        public void obtenirArbreMotsCles(Rafraichissable r) {   
                MotsClesAsynchroneDAO mcoDAO = new MotsClesAsynchroneDAO("obs");
                mcoDAO.obtenirListeMotsCles(this);      
        }

        @Override
        public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {             
                if(nouvelleDonnees instanceof JSONArray) {              
                        JSONArray donneesArbre = (JSONArray)nouvelleDonnees;
                        Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre(Msg.get("projets"), "racine_obs", donneesArbre, false);
                        
                        arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
                        motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
                        
                        // enfin on met à jour l'arbre des mots clés contenu dans le modèle
                        //rafraichirArbreMotsCles(arbreMotsCles);
                        // et on notifie le médiateur de la mise à jour en lui passant une
                        // copie des données
                        observationMediateur.rafraichirArbreMotsCles(arbreMotsCles);
                }
                
                if(nouvelleDonnees instanceof Observation) {
                        observationMediateur.obtenirNombreObservation();
                }
        }

        /**
         * Met à jour l'arbre des mots clés à partir d'un objet
         * 
         * @param o
         *            le nouvel arbre de mots clés
         */
        public void rafraichirArbreMotsCles(Object o) {
                arbreMotsCles = (com.gwtext.client.data.Tree) o;
        }

        /**
         * Met à jour la table de correspondance mots clés / ids à partir d'un objet
         * 
         * @param o
         *            la nouvelle table des mots clés
         */
        @SuppressWarnings("unchecked")
        public void rafraichirMotsCles(Object o) {
                if (o instanceof HashMap) {
                        motsCles = (HashMap<String, String>) o;
                }
        }
        
        /**
         * Va chercher les mots clés associés à une image dans la liste des images
         * chargée dans le modèle
         * 
         * @param r
         *            le rafraichissable auquel on enverra les informations
         * @param id
         *            l'identifiant de l'image
         */
        public void obtenirMotsClesId(Rafraichissable r, String id) {
                Observation o = cacheObservation.get(id);
                String motsClesId = o.getMotsCles();
                String[] motsClesIdTab = motsClesId.split(",");
                r.rafraichir(motsClesIdTab, false);
        }
        
        /**
         * Met à jour les mots clés associés à une obs et appelle le DAO pour
         * synchroniser la base de données
         * 
         * @param ids
         *            les identifiants des observations selectionnées
         * @param motsClesEnCours
         *            les mots clés à appliquer aux observations
         */
        public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) {
        
                String motsCles = "";
                String obsAlier = "";
                int nbObs = 0;
                
                for (int i = 0; i < idsObsALier.length; i++) {
                
                        if (cacheObservation.containsKey(idsObsALier[i])) {
                                
                                if(!motsClesEnCours.endsWith(";") && !motsClesEnCours.startsWith(";")) {
                                        motsCles += ";";
                                }
                                
                                motsCles += motsClesEnCours;
                                
                                nbObs++;
                                
                                Observation m = cacheObservation.get(idsObsALier[i]);
                                obsAlier += ","+m.getId();
                                
                                if(m.getMotsCles() != null && !m.getMotsCles().endsWith(";") && !motsCles.startsWith(";")) {
                                        motsCles += ";";
                                }
                                
                                m.setMotsCles(m.getMotsCles()+motsCles);
                                
                                cacheObservation.put(m.getNumeroOrdre(), m);
                        }
                }
                
                while(obsAlier.startsWith(",")) {
                        obsAlier = obsAlier.replaceFirst(",", "");
                }
                
                if(nbObs > 0) {
                        
                        LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this);
                        lmcDAO.modifier(this,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obsAlier, motsClesEnCours);
                }
        }
        
        
        public void supprimerLiaisonMotCleObservations(
                        Rafraichissable r, String idObs, String idMC) {
                
                LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this);
                lmcDAO.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idObs, idMC);
                
        }
        
        /**
         * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
         * fait la mise à jour de l'arbre des mots clés dans la base
         * 
         * @param n
         *            le nouveau noeud contenant le mot clé
         * @param arbreMC
         *            l'arbre des mots cles en cours
         */
        public void ajouterMotCleDansArbre(TreeNode n,
                        com.gwtext.client.data.Tree arbreMC, Rafraichissable r) {
                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");

                String[] usObj = (String[]) n.getUserObject();
                String motCle = usObj[0];
                String id = usObj[1];
                String parentId = "";

                if (!id.equals("racine_obs")) {
                        String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
                        if(!parentUsObj[1].equals("racine_obs")) {
                                parentId = parentUsObj[1];
                        }
                }
                
                rafraichirArbreMotsCles(arbreMC);
                motsCles.put(id, motCle);

                String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&motcle="
                                + motCle + "&id=" + id + "&parent=" + parentId;
                MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
        }

        /**
         * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
         * supprimer les mots clés associés dans la base
         * 
         * @param n
         *            le noeud à supprimer
         * @param arbreMC
         *            l'arbre des mots clés en cours
         */
        public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {

                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");

                String[] usObj = (String[]) n.getUserObject();
                String id = usObj[1];
                
                rafraichirArbreMotsCles(arbreMC);

                MCDao.supprimerBaseDeDonnees(id, r);

        }

        /**
         * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
         * DAO qui synchronise la modification dans la base de données
         * 
         * @param n
         *            le noeud modifié
         * @param arbreMC
         *            l'arbre des mots clés en cours
         */
        public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {

                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");

                String[] usObj = (String[]) n.getUserObject();
                String motCle = usObj[0];
                String id = usObj[1];
                String parentId = "";

                if (!id.equals("racine_obs")) {
                        String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
                        if(!parentUsObj[1].equals("racine_obs")) {
                                parentId = parentUsObj[1];
                        }
                }

                rafraichirArbreMotsCles(arbreMC);

                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
                                + parentId;
                MCDao.modifierBaseDeDonnees(motCleModifie, r);

        }

        /**
         * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
         * reorganise l'arbre dans la base de donnees suivant le changement
         * 
         * @param n
         *            le noeud deplace (et son sous arbre associe)
         * @param arbreMC
         *            l'arbre des mots cles en cours
         */
        public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");

                String[] usObj = (String[]) n.getUserObject();
                String motCle = usObj[0];
                String id = usObj[1];
                String parentId = "";
                
                if (!id.equals("racine_obs")) {
                        String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
                        if(!parentUsObj[1].equals("racine_obs")) {
                                parentId = parentUsObj[1];
                        }
                }
                
                rafraichirArbreMotsCles(arbreMC);

                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
                                + parentId;
                MCDao.deplacerBaseDeDonnees(motCleModifie, r);
        }
        
        /**
         * Ajoute un nouveau mot clés à la liste des mots clés locale
         * 
         * @param text
         *            le mot clé
         * @param id
         *            l'identifiant du mot clé
         */
        public void mettreAjourMotsClesId(String text, String id) {
                motsCles.put(id, text);
        }
        
        public String obtenirTexteMotCle(String id) {
                
                String correspondanceId = "";
                
                String motCleTexte = motsCles.get(id);
                
                if(motCleTexte != null) {
                        correspondanceId = motCleTexte;
                }
                
                return correspondanceId;
        }
        
        public void rafraichirCacheObservation(ListeObservation li) {
                cacheObservation = li ;
        }

        public ListeObservation getCacheObservation() {
                return cacheObservation ;
        }
        
        public String getIdPourOrdreObs(String ordreObs) {
                return (cacheObservation.get(ordreObs) != null) ? cacheObservation.get(ordreObs).getId() : null;
        }

        public void obtenirInformationLocalite(Rafraichissable r, String nomLocalite, String code) {
                InformationLocaliteDAO infoLocalite = new InformationLocaliteDAO(r);
                infoLocalite.obtenirInfosLocalite(r, nomLocalite, code);
        }
        
        public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) {
                InformationLocaliteDAO infoLocalite = new InformationLocaliteDAO(r);
                infoLocalite.obtenirLocalitePlusProche(r, lng, lat);
        }
}