Subversion Repositories eFlore/Applications.cel

Rev

Rev 156 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

package org.tela_botanica.client.observation;


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

import java.util.HashMap;
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.ExportObservationsDAO;
import org.tela_botanica.client.modeles.ImageAsynchroneDAO;
import org.tela_botanica.client.modeles.ImageCarnet;
import org.tela_botanica.client.modeles.ImageGeneriqueVueAsynchroneDAO;
import org.tela_botanica.client.modeles.ImageInformationRepartitionAsynchroneDAO;
import org.tela_botanica.client.modeles.ImportObservationAsynchroneDAO;
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.ListeObservation;
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.MotsClesAsynchroneDAO;
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;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
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) ;
        
        /**
         * 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();
                
        }



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

        public void rafraichir(Object nouvelleDonnees,
                        boolean repandreRaffraichissement) {
                
                if(nouvelleDonnees instanceof JSONArray) {
                        // alors on a reçu les informations sur les mots clés
                        JSONArray reponse = (JSONArray) nouvelleDonnees;

                        final int taillemax = reponse.size();

                        // si le tableau est vide
                        if (taillemax == 0) {
                                // on crée un arbre vide
                                TreeNode root = new TreeNode();
                                root.setId("racine");
                                root.setText("Tags");
                                String[] usObj = { "Tags", "racine" };
                                root.setUserObject(usObj);
                                arbreMotsCles.setRootNode(root);
                        }

                        // pour chacun des élements du tableau
                        for (int j = 0; j < taillemax; j++) {
                                // on extrait les élements du tableau
                                if (reponse.get(j).isObject() != null) {
                                        JSONObject noeud = (JSONObject) reponse.get(j);

                                        String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur")
                                                        .isString().stringValue();
                                        String mot_cle = noeud.get("cmc_mot_cle").isString()
                                                        .stringValue();
                                        String parent = noeud.get("cmc_id_parent").isString()
                                                        .stringValue();

                                        String[] usObj = { mot_cle, id_noeud };

                                        // et on construit l'arbre à partir de la racine (qui est
                                        // toujoursl e premier élément)
                                        if (id_noeud.equals("racine")) {
                                                TreeNode root = new TreeNode();
                                                root.setId(id_noeud);
                                                root.setText(mot_cle);
                                                root.setUserObject(usObj);
                                                arbreMotsCles.setRootNode(root);
                                        } else {
                                                // et en ajoutant les noeuds un à un (qui sont renvoyé
                                                // dans l'ordre hierarchique de leur niveau
                                                // ce qui permet de les traiter séquentiellement)
                                                TreeNode node = new TreeNode();
                                                node.setId(id_noeud);
                                                node.setText(mot_cle);
                                                node.setChecked(false);
                                                Node parentNode = arbreMotsCles.getNodeById(parent);
                                                node.setUserObject(usObj);
                                                parentNode.appendChild(node);
                                        }
                                }
                        }
                        // 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);
                }
                
        }

        /**
         * 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) {
                observationMediateur.transmettreDonnees(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 image et appelle le DAO pour
         * synchroniser la base de données
         * 
         * @param ids
         *            les identifiants des images selectionnées
         * @param motsClesEnCours
         *            les mots clés à appliquer aux images
         * @param arbreMC
         *            l'arbre de mots clés en cours
         */
        public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,
                        com.gwtext.client.data.Tree arbreMC) {
                for (int i = 0; i < ids.length; i++) {
                        if (cacheObservation.containsKey(ids[i])) {
                                Observation o = (Observation) cacheObservation.get(ids[i]);
                                o.setMotsCles(motsClesEnCours);

                                ObservationAsynchroneDAO oDao = new ObservationAsynchroneDAO(this);
                                oDao.modifier(this,observationMediateur.getIdentifiant(),o);
                        }
                }

                rafraichirArbreMotsCles(arbreMC);
        }
        
        /**
         * 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) {
                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

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

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

                rafraichirArbreMotsCles(arbreMC);

                String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
                                + motCle + "&id=" + id + "&parent=" + parentId;
                MCDao.ajouterBaseDeDonnees(nouveauMotCle);
        }

        /**
         * 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) {

                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

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

                MCDao.supprimerBaseDeDonnees(id);

        }

        /**
         * 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) {

                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

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

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

                rafraichirArbreMotsCles(arbreMC);

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

        }

        /**
         * 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) {
                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

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

                rafraichirArbreMotsCles(arbreMC);

                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
                                + parentId;
                MCDao.deplacerBaseDeDonnees(motCleModifie);
        }
        
        /**
         * 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 void rafraichirCacheObservation(ListeObservation li) {
                cacheObservation = li ;
        }

        public ListeObservation getCacheObservation() {
                return cacheObservation ;
        }


        
}