Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.observation;

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

import java.util.HashMap;

import org.tela_botanica.client.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.InformationCommuneDAO;

import org.tela_botanica.client.modeles.LiaisonMotsClesObsAsynchroneDAO;

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.ListeReferentielPersoAsynchroneDAO;

import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;

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 org.tela_botanica.client.modeles.Utilisateur;

import org.tela_botanica.client.modeles.ListeReferentielPerso.TypesReferentiels;

import org.tela_botanica.client.vues.observation.ListeObservationVue;

import com.google.gwt.core.client.GWT;

import com.google.gwt.json.client.JSONArray;

import com.google.gwt.json.client.JSONObject;

import com.google.gwt.maps.client.geom.LatLng;

import com.google.gwt.user.client.Window;

import com.gwtext.client.data.Node;

import com.gwtext.client.data.Tree;

import com.gwtext.client.widgets.map.LatLonPoint;

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+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, 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 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, 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 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, 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 ordreObservation) {

		LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ;

		liaDAO.obtenirLiaisonsObservationsImages(r, ordreObservation,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()) ;

	}

	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(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres) ;

	}

	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(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_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_utilisateur")

							.isString().stringValue();

					String mot_cle = noeud.get("mot_cle").isString()

							.stringValue();

					String parent = noeud.get("ce_mot_cle_utilisateur_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 += ";";

				}

				obsAlier += ","+idsObsALier[i];

				motsCles += motsClesEnCours;

				nbObs++;

				Observation m = cacheObservation.get(idsObsALier[i]);

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

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

		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(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_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 void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) {

		InformationCommuneDAO infocommune = new InformationCommuneDAO(r);

		infocommune.obtenirInfosCommune(r, nomCommune, codePostal);

	}

	public void obtenirInformationCoord(Rafraichissable r, LatLng coord) {

		InformationCommuneDAO infocommune = new InformationCommuneDAO(r);

		infocommune.obtenirCommunePlusProche(r, coord.getLongitude(), coord.getLatitude());

	}

}