Subversion Repositories eFlore/Applications.cel

Compare Revisions

Problem with comparison.

Ignore whitespace Rev HEAD → Rev 383

/trunk/src/org/tela_botanica/client/observation/ObservationModele.java
New file
0,0 → 1,710
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.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.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;
 
 
/**
* 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);
}
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 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("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_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);
}
}
}
// 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 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 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) {
Observation o = new Observation();
o.setNumeroOrdre(obsAlier);
o.setMotsCles(motsCles);
ListeObservationAsynchroneDAO loDao = new ListeObservationAsynchroneDAO(this);
loDao.modifierEnMasse(this,observationMediateur.getIdentifiant(),o);
}
}
/**
* 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=" + 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];
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 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());
}
 
}