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.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 org.tela_botanica.client.vues.observation.ListeObservationVue;

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

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

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

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;

	/**

	 * 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) ;

	}

	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, 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 modifierObservationEnMasse(

			Rafraichissable r, Observation obs) {

		ListeObservationAsynchroneDAO liObsDAO=new ListeObservationAsynchroneDAO(this);

		liObsDAO.modifierEnMasse(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 ;

	}

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

	}

}