Rev 1488 | Rev 1679 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed
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.google.gwt.maps.client.geom.LatLng;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 nouveauestInstancie = 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èresString[][] 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 imagesListeObservationAsynchroneDAO 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[][] 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("obs");mcoDAO.obtenirListeMotsCles(this);}@Overridepublic void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) {if(nouvelleDonnees instanceof JSONArray) {// alors on a reçu les informations sur les mots clésJSONArray reponse = (JSONArray) nouvelleDonnees;final int taillemax = reponse.size();// si le tableau est videif (taillemax == 0) {// on crée un arbre videTreeNode 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 tableaufor (int j = 0; j < taillemax; j++) {// on extrait les élements du tableauif (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éesobservationMediateur.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, LatLng coord) {InformationCommuneDAO infocommune = new InformationCommuneDAO(r);infocommune.obtenirCommunePlusProche(r, coord.getLongitude(), coord.getLatitude());}}