Rev 2609 | Blame | 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.i18n.Msg;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.InformationLocaliteDAO;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.ListeReferentielLocaliteAsynchroneDAO;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 org.tela_botanica.client.util.MotsClesUtilitaire;import com.google.gwt.json.client.JSONArray;import com.google.gwt.json.client.JSONObject;import com.google.gwt.user.client.Window;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) ;/*** 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+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 imagesListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);loaDAO.obtenirListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres2);}/**** 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);}@Overridepublic void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {if(nouvelleDonnees instanceof JSONArray) {JSONArray donneesArbre = (JSONArray)nouvelleDonnees;Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre(Msg.get("projets"), "racine_obs", donneesArbre, false);arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];// 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, Rafraichissable r) {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();if(!parentUsObj[1].equals("racine_obs")) {parentId = parentUsObj[1];}}rafraichirArbreMotsCles(arbreMC);motsCles.put(id, motCle);String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&motcle="+ motCle + "&id=" + id + "&parent=" + parentId;MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);}/*** 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, Rafraichissable r) {MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");String[] usObj = (String[]) n.getUserObject();String id = usObj[1];rafraichirArbreMotsCles(arbreMC);MCDao.supprimerBaseDeDonnees(id, r);}/*** 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, Rafraichissable r) {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();if(!parentUsObj[1].equals("racine_obs")) {parentId = parentUsObj[1];}}rafraichirArbreMotsCles(arbreMC);String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="+ parentId;MCDao.modifierBaseDeDonnees(motCleModifie, r);}/*** 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, Rafraichissable r) {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();if(!parentUsObj[1].equals("racine_obs")) {parentId = parentUsObj[1];}}rafraichirArbreMotsCles(arbreMC);String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="+ parentId;MCDao.deplacerBaseDeDonnees(motCleModifie, r);}/*** 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 obtenirInformationLocalite(Rafraichissable r, String nomLocalite, String code) {InformationLocaliteDAO infoLocalite = new InformationLocaliteDAO(r);infoLocalite.obtenirInfosLocalite(r, nomLocalite, code);}public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) {InformationLocaliteDAO infoLocalite = new InformationLocaliteDAO(r);infoLocalite.obtenirLocalitePlusProche(r, lng, lat);}}