WebSVN – eFlore/Applications.cel – Path Comparison – / – /trunk/src/ Rev 155 and /trunk/src/ Rev 156

Ignore whitespace Rev 155 → Rev 156

/trunk/src/org/tela_botanica/client/observation/ImportObservationAsynchroneDAO.java
File deleted

 /trunk/src/org/tela_botanica/client/observation/ObservationMediateur.java
 ,10 → 4,15
 // TODO : systematiser les onQuelquechose, appelle depuis les vues
+import java.util.HashMap;
 import org.tela_botanica.client.CarnetEnLigneMediateur;
+import org.tela_botanica.client.image.ImageMediateur;
 import org.tela_botanica.client.interfaces.Rafraichissable;
 import org.tela_botanica.client.modeles.ListeObservation;
 import org.tela_botanica.client.modeles.Observation;
+import org.tela_botanica.client.vues.ArbreMotsClesObsVue;
+import org.tela_botanica.client.vues.ArbreMotsClesVue;
 import org.tela_botanica.client.vues.FormulaireSaisieObservationVue;
 import org.tela_botanica.client.vues.ImageGeneriqueVue;
 import org.tela_botanica.client.vues.InformationRepartitionVue;
 ,16 → 30,26
 import com.gwtext.client.core.Ext;
 import com.gwtext.client.core.ExtElement;
 import com.gwtext.client.core.RegionPosition;
+import com.gwtext.client.data.Record;
+import com.gwtext.client.data.Tree;
 import com.gwtext.client.widgets.BoxComponent;
 import com.gwtext.client.widgets.Component;
 import com.gwtext.client.widgets.Container;
 import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.TabPanel;
 import com.gwtext.client.widgets.event.ContainerListener;
 import com.gwtext.client.widgets.event.ContainerListenerAdapter;
 import com.gwtext.client.widgets.layout.BorderLayout;
 import com.gwtext.client.widgets.layout.BorderLayoutData;
+import com.gwtext.client.widgets.layout.FitLayout;
 import com.gwtext.client.widgets.layout.RowLayout;
 import com.gwtext.client.widgets.layout.RowLayoutData;
+import com.gwtext.client.widgets.menu.BaseItem;
+import com.gwtext.client.widgets.menu.Item;
+import com.gwtext.client.widgets.menu.Menu;
+import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
+import com.gwtext.client.widgets.tree.TreeEditor;
+import com.gwtext.client.widgets.tree.TreeNode;
 /**
 ,24 → 106,18
         /**
          * booleen explicitant s'il y a une selection en cours
          */
-        private boolean selection = false ;
+        private boolean selection = false ;
         /**
-         * La liste des observations affichées en cours (verifier utilité)
-         */
-        private ListeObservation cacheObservation = new ListeObservation(0) ;
-        /**
-        /**
          * panneau conteneur pour le panneau  des informations lies à l'observation
          */
         private Panel details = new Panel("Détails");
+        private Panel panelMotsCles = new Panel("Mots Clés");
+        private ArbreMotsClesObsVue arbreMotsClesVue = null ;
+        private TabPanel detailsEtMotsCles = new TabPanel();
         /**
 ,14 → 216,24
                 centre.add(conteneurFormulaire, new RowLayoutData(210));
                 centre.add(listeObservation, new RowLayoutData());
+                Panel conteneurDetailsMotsClés = new Panel("Détails");
                 // on initialise le volet qui contient les details
-                details.setWidth("10%");
-                details.setTitleCollapse(true);
-                details.setCollapsible(true);
+                conteneurDetailsMotsClés.setWidth("10%");
+                conteneurDetailsMotsClés.setTitleCollapse(true);
+                conteneurDetailsMotsClés.setCollapsible(true);
+                conteneurDetailsMotsClés.add(detailsEtMotsCles);
+                conteneurDetailsMotsClés.setLayout(new FitLayout());
+                details.setAutoScroll(true);
                 details.setLayout(new RowLayout());
-                details.setAutoScroll(true);
+                details.setWidth("100%");
+                arbreMotsClesVue = new ArbreMotsClesObsVue(this) ;
+                panelMotsCles.add(arbreMotsClesVue);
                 // Information de repartition
                 informationRepartitionVue=new InformationRepartitionVue(this);
                 // TODO : calcul de la hauteur automatique par le panel ?
 ,7 → 261,13
                 filtres.setTitleCollapse(true);
                 filtres.setCollapsible(true);
-                panneauPrincipalObservation.add(details,regionEst);
+                detailsEtMotsCles.add(details);
+                //detailsEtMotsCles.add(panelMotsCles);
+                panelMotsCles.hide();
+                panneauPrincipalObservation.add(conteneurDetailsMotsClés,regionEst);
                 panneauPrincipalObservation.add(filtres,regionOuest);
                 panneauPrincipalObservation.add(centre,regionCentre);
 ,12 → 338,8
         public void onRafraichissementListeObservations() {
-                cacheObservation = listeObservation.getCacheListeObservation() ;
-                if(cacheObservation.size() == 0)
-                {
-                        //formulaireSaisieObservationVue.raz() ;
-                }
-                carnetEnLigneMediateur.donneesRafraichies(cacheObservation) ;
+                carnetEnLigneMediateur.donneesImagesVersObs(listeObservation.getCacheListeObservation());
+                observationModele.rafraichirCacheObservation(listeObservation.getCacheListeObservation());
         }
         /**
 ,7 → 354,7
         public void onClicListeObservation(int rowIndex, String ordreObservation) {
-                Observation obs = cacheObservation.get(ordreObservation) ;
+                Observation obs = obtenirCacheObservation().get(ordreObservation) ;
                 if(GWT.isScript()) {
                         masquerChargementInfosObservations() ;
 ,6 → 372,9
                 observationModele.obtenirImageGenerique(imageGeneriqueVue,numeroNomenclaturalSaisiObservation) ;
                 observationModele.obtenirLiaisonImage(mvz, ordreObservation) ;
+                observationModele.obtenirMotsClesId(arbreMotsClesVue, ordreObservation);
+                //arbreMotsClesVue.cocherMotsCles(motsClesIds);
         }
 ,7 → 449,7
         public void obtenirCacheObservation(Rafraichissable r) {
-                r.rafraichir(cacheObservation, false) ;
+                r.rafraichir(observationModele.getCacheObservation(), false) ;
         }
 ,7 → 540,7
         public String[][] renvoyerFiltres()
         {
                 int longueur = 0;
-                        /*String[] filtresMotsCles = filtres.getMotsClesObsVue().renvoyerValeursAFiltrer();
+                        /*String[] filtresMotsCles = filtres.getArbreMotsClesFiltreVue().renvoyerValeursAFiltrer();
                         if(filtresMotsCles.length > 0) {
                                 longueur++ ;
                         }*/
 ,8 → 626,6
         }
         // Getters
 ,9 → 637,9
         public void masquerChargementInfosObservations()
         {
-                ExtElement masked = Ext.get(details.getId());
+                ExtElement masked = Ext.get(detailsEtMotsCles.getId());
-                if (masked != null && !masked.isMasked()) {
+                if (details.isVisible() && masked != null && !masked.isMasked()) {
                         informationRepartitionVue.raz() ;
                         imageGeneriqueVue.raz() ;
                         masked.mask("Chargement", true);
 ,9 → 648,9
         public void deMasquerChargementInfosObservations()
         {
-                ExtElement masked = Ext.get(details.getId());
+                ExtElement masked = Ext.get(detailsEtMotsCles.getId());
-                if (masked != null && masked.isMasked()) {
+                if (details.isVisible() && masked != null && masked.isMasked()) {
                         masked.unmask() ;
                 }
         }
 ,6 → 687,7
                         formulaireSaisieObservationVue.raz() ;
                         filtres.getArbreDateObservationFiltreVue().raz() ;
                         filtres.getArbreEntiteGeographiqueObservationFiltreVue().raz() ;
+                        filtres.getArbreMotsClesFiltreVue().raz();
                         informationRepartitionVue.raz() ;
                         imageGeneriqueVue.raz() ;
                         mvz.raz() ;
 ,60 → 782,158
         }
-        /*public void ajouterMotCleRecherche(String motCle) {
+        public void montrerContextMenuArbre(final TreeNode n, EventObject e,
+                        TreeEditor te) {
+                        Menu mn = new Menu();
+                        final com.gwtext.client.widgets.menu.Item ajoutN = new Item(
+                                        "Ajouter mot cle");
+                        final com.gwtext.client.widgets.menu.Item suppN = new Item(
+                                        "Supprimer mot cle");
+                        mn.addItem(ajoutN);
+                        mn.addItem(suppN);
+                        mn.addListener(new MenuListenerAdapter() {
+                                public void onItemClick(BaseItem item, EventObject e) {
+                                        if (item.equals(suppN)) {
+                                                arbreMotsClesVue
+                                                                .supprimerNoeud(n);
+                                        }
+                                        if (item.equals(ajoutN)) {
+                                                arbreMotsClesVue.ajouterNoeud(
+                                                                n);
+                                        }
+                                }
+                        });
+                        mn.showAt(e.getXY());
-                filtres.getMotsClesObsVue().rafraichir(motCle, false);
         }
-        public void obtenirNuageMotsCles(Rafraichissable r) {
-                observationModele.obtenirNuageMotsCles(r);
+        /**
+         * Appelle le modèle pour mettre à jour la paire mot-clé / identifiant du
+         * mot clé
+         *
+         * @param text
+         *            le texte du mot clé
+         * @param id
+         *            l'identifiant du mot clé
+         */
+        public void mettreAjourMotsClesId(String text, String id) {
+                observationModele.mettreAjourMotsClesId(text, id);
         }
+        /**
+         * Récupère les identifiants des images selectionnés et appelle le modèle
+         * pour qu'il mette à jour les associations mots clés/images
+         *
+         * @param motsClesEnCours
+         *            les mots clés à associer aux images selectionnés séparés par
+         *            une ','
+         * @param arbreMC
+         *            l'arbre des mots clés à mettre à jour
+         */
+        public void mettreAjourMotsCles(String motsClesEnCours, Tree arbreMC) {
-        public void afficherNuageMotsCles() {
-                if(nuaMC != null && nuaMC.isVisible()) {
-                        nuaMC.hide();
-                        nuaMC.close();
-                        nuaMC = null;
-                }
-                else {
-                        nuaMC = new NuageMotsClesVue(this);
-                        nuaMC.show(filtres.getMotsClesObsVue().getElement());
-                }
+                String[] ids = listeObservation.getIdSelectionnees();
+                observationModele.mettreAjourMotsCles(ids, motsClesEnCours, arbreMC);
         }
+        /**
+         * Appelle le médiateur pour qu'il ajoute un mot clé dans l'arbre des mots
+         * clés
+         *
+         * @param n
+         *            le noeud à ajouter à l'arbre
+         * @param arbreMC
+         *            le nouvel arbre de mots clés à mettre à jour
+         */
+        public void ajouterMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                observationModele.ajouterMotCleDansArbre(n, arbreMC);
+                getPanneauFiltres().getArbreMotsClesFiltreVue().rafraichir(n, false);
-        public void AjouterMotsClesEnMasse(String motsAAjouter) {
+        }
+        /**
+         * Appelle le médiateur pour qu'il supprime un mot clé et son sous arbre
+         * dans l'arbre des mots clés
+         *
+         * @param n
+         *            le noeud à supprimer
+         * @param arbreMC
+         *            le nouvel arbre de mots clés à mettre à jour
+         */
+        public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                observationModele.supprimerMotCleDansArbre(n, arbreMC);
+                getPanneauFiltres().getArbreMotsClesFiltreVue().rafraichir(n.getId(), false);
+        }
+        /**
+         * Appelle le médiateur pour qu'il modifie un mot clé dans l'arbre des mots
+         * clés
+         *
+         * @param n
+         *            le noeud à modifier
+         * @param arbreMC
+         *            le nouvel arbre de mots clés à mettre à jour
+         */
+        public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                observationModele.modifierMotCleDansArbre(n, arbreMC);
+                getPanneauFiltres().getArbreMotsClesFiltreVue().rafraichir(n, false);
+        }
+        /**
+         * Appelle le médiateur pour qu'il déplace un mot clé et son sous arbre dans
+         * l'arbre des mots clés
+         *
+         * @param n
+         *            le noeud à déplacer
+         * @param arbreMC
+         *            le nouvel arbre de mots clés à mettre à jour
+         */
+        public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                observationModele.deplacerMotCleDansArbre(n, arbreMC);
+                getPanneauFiltres().getArbreMotsClesFiltreVue().rafraichir(n, false);
+        }
+        public void rafraichirArbreMotsCles(Tree arbreMotsCles) {
-                String[] numObs = listeObservation.getIdSelectionnees();
-                String numObsApl = "" ;
+                arbreMotsClesVue.rafraichir(arbreMotsCles, false);
+                getPanneauFiltres().getArbreMotsClesFiltreVue().rafraichir(arbreMotsCles, false);
-                if(numObs.length < 1) {
-                        return;
-                }
-                for(int i = 0 ; i < numObs.length ; i++) {
-                        numObsApl += numObs[i] ;
-                        if(i != numObs.length - 1) {
-                                numObsApl +="," ;
-                        }
-                }
-                motsAAjouter = motsAAjouter.replace("\n", " ");
-                motsAAjouter = motsAAjouter.replace(" ", ";");
-                observationModele.ajouterMotsCles(listeObservation,numObsApl,motsAAjouter);
         }
-        public void afficherSaisieMotsCles(Element e) {
+        public void obtenirArbreMotsCles(Rafraichissable r) {
-                SaisieMotsClesVue suaMC = new SaisieMotsClesVue(this);
-                suaMC.show(e.getId());
-        }*/
+                observationModele.obtenirArbreMotsCles(r);
+        }
+        public ListeObservation obtenirCacheObservation() {
+                return observationModele.getCacheObservation();
+        }
+        public void donneesExterieures(Object nouvelleDonnees) {
+                if(nouvelleDonnees instanceof Tree) {
+                        Tree arbreMotsCles = (Tree)nouvelleDonnees ;
+                        observationModele.rafraichirArbreMotsCles(nouvelleDonnees);
+                        rafraichirArbreMotsCles(arbreMotsCles);
+                }
+        }
+        public void transmettreDonnees(Object o) {
+                carnetEnLigneMediateur.donneesObsVersImages(o);
+        }
 }

 /trunk/src/org/tela_botanica/client/observation/ObservationModele.java
 ,17 → 3,24
 //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;
 ,9 → 27,14
 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  {
+public class ObservationModele implements Rafraichissable {
 ,9 → 60,20
         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
          *
          */
 ,5 → 398,283
                 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 ;
+        }
 }

Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 155 → Rev 156