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.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.InformationCommuneDAO;
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.ListeReferentielCommuneAsynchroneDAO;
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 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;
	private ListeReferentielPersoAsynchroneDAO refPersoDAO=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, 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);		
	}
	
 
	/**
	 * Obtenir une liste de commune 
	 * @param r
	 * @param critere
	 */
	
	public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
		
		if (refDAO==null) {
			refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
		}
		refDAO.obtenirListeDonnees(r, critere);
 
	}
	
	/**
	 * Obtenir une liste de commune 
	 * @param r
	 * @param critere
	 */
	public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) {
		
		if (refPersoDAO==null) {
			refPersoDAO=new ListeReferentielPersoAsynchroneDAO(this);
		}
		
		refPersoDAO.setRefDemande(referentiel);
		refPersoDAO.obtenirListeDonnees(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), critere);
 
	}
	
	/**
	 * Obtenir une liste de nom scientifique de plante
	 * @param r
	 * @param critere
	 */	
	public void obtenirListeReferentielNom(Rafraichissable r, String referentiel, String critere) {
		
		if (nomDAO==null) {
			nomDAO=new ListeReferentielNomAsynchroneDAO(this);
		}
		nomDAO.obtenirListeDonnees(r, referentiel, 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, 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) {
			// 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_obs");
				root.setText("Projets");
				String[] usObj = { "Projets", "racine_obs" };
				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("id_mot_cle_obs")
							.isString().stringValue();
					String mot_cle = noeud.get("mot_cle").isString()
							.stringValue();
					String parent = noeud.get("ce_mot_cle_obs_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_obs")) {
						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);
					}
					
					motsCles.put(id_noeud, mot_cle);
				}
			}
			
			// 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) {
		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();
			parentId = parentUsObj[1];
		} else {
			parentId = "racine_obs";
		}
		
		rafraichirArbreMotsCles(arbreMC);
 
		String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&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("obs");
 
		String[] usObj = (String[]) n.getUserObject();
		String id = usObj[1];
		
		rafraichirArbreMotsCles(arbreMC);
 
		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("obs");
 
		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("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();
			parentId = parentUsObj[1];
		} else {
			parentId = "racine_obs";
		}
		
		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 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 obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) {
		InformationCommuneDAO infocommune = new InformationCommuneDAO(r);
		infocommune.obtenirInfosCommune(r, nomCommune, codePostal);
	}
	
	public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) {
		InformationCommuneDAO infocommune = new InformationCommuneDAO(r);
		infocommune.obtenirCommunePlusProche(r, lng, lat);
	}
}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/observation/ObservationModele.java @ 2042 – Rev 1958 → 2033

Rev 1958		Rev 2033
1	`package org.tela_botanica.client.observation;`	1	`package org.tela_botanica.client.observation;`
2		2
3		3
4	`//TODO : normaliser les noms de methodes (obtenir, ajouter ...)`	4	`//TODO : normaliser les noms de methodes (obtenir, ajouter ...)`
5		5
6	`import java.util.HashMap;`	6	`import java.util.HashMap;`
7	`import org.tela_botanica.client.interfaces.Rafraichissable;`	7	`import org.tela_botanica.client.interfaces.Rafraichissable;`
8	`import org.tela_botanica.client.modeles.dao.ExportObservationsDAO;`	8	`import org.tela_botanica.client.modeles.dao.ExportObservationsDAO;`
9	`import org.tela_botanica.client.modeles.dao.ImageGeneriqueVueAsynchroneDAO;`	9	`import org.tela_botanica.client.modeles.dao.ImageGeneriqueVueAsynchroneDAO;`
10	`import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO;`	10	`import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO;`
11	`import org.tela_botanica.client.modeles.dao.ImportObservationAsynchroneDAO;`	11	`import org.tela_botanica.client.modeles.dao.ImportObservationAsynchroneDAO;`
12	`import org.tela_botanica.client.modeles.dao.InformationCommuneDAO;`	12	`import org.tela_botanica.client.modeles.dao.InformationCommuneDAO;`
13	`import org.tela_botanica.client.modeles.dao.LiaisonMotsClesObsAsynchroneDAO;`	13	`import org.tela_botanica.client.modeles.dao.LiaisonMotsClesObsAsynchroneDAO;`
14	`import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;`	14	`import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;`
15	`import org.tela_botanica.client.modeles.dao.ListeDateObservationAsynchroneDAO;`	15	`import org.tela_botanica.client.modeles.dao.ListeDateObservationAsynchroneDAO;`
16	`import org.tela_botanica.client.modeles.dao.ListeEntiteGeographiqueObservationAsynchroneDAO;`	16	`import org.tela_botanica.client.modeles.dao.ListeEntiteGeographiqueObservationAsynchroneDAO;`
17	`import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;`	17	`import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;`
18	`import org.tela_botanica.client.modeles.dao.ListeReferentielCommuneAsynchroneDAO;`	18	`import org.tela_botanica.client.modeles.dao.ListeReferentielCommuneAsynchroneDAO;`
19	`import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO;`	19	`import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO;`
20	`import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO;`	20	`import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO;`
21	`import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;`	21	`import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;`
22	`import org.tela_botanica.client.modeles.dao.NomRetenuAsynchroneDAO;`	22	`import org.tela_botanica.client.modeles.dao.NomRetenuAsynchroneDAO;`
23	`import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;`	23	`import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;`
24	`import org.tela_botanica.client.modeles.dao.ObservationAsynchroneDAO;`	24	`import org.tela_botanica.client.modeles.dao.ObservationAsynchroneDAO;`
25	`import org.tela_botanica.client.modeles.dao.TransmissionObservationAsynchroneDAO;`	25	`import org.tela_botanica.client.modeles.dao.TransmissionObservationAsynchroneDAO;`
26	`import org.tela_botanica.client.modeles.objets.Configuration;`	26	`import org.tela_botanica.client.modeles.objets.Configuration;`
27	`import org.tela_botanica.client.modeles.objets.ListeObservation;`	27	`import org.tela_botanica.client.modeles.objets.ListeObservation;`
28	`import org.tela_botanica.client.modeles.objets.Observation;`	28	`import org.tela_botanica.client.modeles.objets.Observation;`
29	`import org.tela_botanica.client.modeles.objets.Utilisateur;`	29	`import org.tela_botanica.client.modeles.objets.Utilisateur;`
30	`import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;`	30	`import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;`
31	`import com.google.gwt.json.client.JSONArray;`	31	`import com.google.gwt.json.client.JSONArray;`
32	`import com.google.gwt.json.client.JSONObject;`	32	`import com.google.gwt.json.client.JSONObject;`
33	`import com.gwtext.client.data.Node;`	33	`import com.gwtext.client.data.Node;`
34	`import com.gwtext.client.data.Tree;`	34	`import com.gwtext.client.data.Tree;`
35	`import com.gwtext.client.widgets.tree.TreeNode;`	35	`import com.gwtext.client.widgets.tree.TreeNode;`
36		36
37		37
38	`public class ObservationModele implements Rafraichissable {`	38	`public class ObservationModele implements Rafraichissable {`
39		39
40	`/**`	40	`/**`