WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/observation/ObservationModele.java

 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  {
+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 ;
+	}
+}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/observation/ObservationModele.java @ 2643 – Rev 152 → 156