New file |
0,0 → 1,680 |
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.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 com.google.gwt.json.client.JSONArray; |
import com.google.gwt.json.client.JSONObject; |
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; |
|
|
|
|
/** |
* 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) ; |
|
} |
|
|
/** |
* 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 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 ; |
} |
|
|
|
} |