Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 1546 → Rev 1547

/branches/v1.6-croc/src/org/tela_botanica/client/observation/ObservationMediateur.java
New file
0,0 → 1,1265
package org.tela_botanica.client.observation;
 
 
 
// TODO : systematiser les onQuelquechose, appelle depuis les vues
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.objets.InfosReferentielNom;
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.vues.observation.CartographieObservationVue;
import org.tela_botanica.client.vues.observation.FormulaireImportObservationVue;
import org.tela_botanica.client.vues.observation.FormulaireSaisieObservationVue;
import org.tela_botanica.client.vues.observation.ListeObservationVue;
import org.tela_botanica.client.vues.observation.MenuObservationVue;
import org.tela_botanica.client.vues.observation.PanneauFiltresObservationVues;
import org.tela_botanica.client.vues.observation.indicateurs.ImageGeneriqueVue;
import org.tela_botanica.client.vues.observation.indicateurs.InformationRepartitionVue;
import org.tela_botanica.client.vues.observation.indicateurs.LienExterneVue;
import org.tela_botanica.client.vues.observation.indicateurs.MiniZoomImageVue;
 
import com.google.gwt.core.client.GWT;
import com.google.gwt.maps.client.geom.LatLng;
import com.google.gwt.user.client.History;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.RegionPosition;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.Tree;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
import com.gwtext.client.widgets.layout.FitLayout;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
import com.gwtext.client.widgets.tree.TreeNode;
 
 
/**
* Mediateur gérant les interactions entre vues et les echanges de données
* C'est un singleton.
* @author aurelien
*
*/
public class ObservationMediateur {
/**
* booleen qui verifie l'unicite de l'instance (donc static)
*/
private static boolean estInstancie = false ;
 
/**
* pointeur sur le médiateur (pour le pattern singleton)
*/
private static ObservationMediateur thisMediateur = null ;
/** Mediateur general de l'application carnet en ligne
*
*
*/
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
/**
* modele de données
*/
private ObservationModele observationModele = null ;
/**
* panneau principal des Observation (onglet "observation")
*/
private final Panel panneauPrincipalObservation = new Panel("Observations");
/**
* liste détaillée des Observations
*/
public ListeObservationVue listeObservation = null ;
/**
* Saisie des Observations
*/
private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null;
/**
*
* Import des observations depuis un fichier
*
*/
private FormulaireImportObservationVue formImportObs=null;
/**
* Cartographie
*/
private CartographieObservationVue cartoObservationVue = null;
 
/**
* booleen explicitant s'il y a une selection en cours
*/
private boolean selection = false ;
/**
* panneau conteneur pour le panneau des informations lies à l'observation
*/
private Panel details = new Panel("Details");
 
private LienExterneVue liExtVue = null;
 
/**
* panneau conteneur pour le panneau des filtres
*/
private PanneauFiltresObservationVues filtres = null;
 
/**
* panneau d'information de repartition sur le nom selectionné
*
*/
private InformationRepartitionVue informationRepartitionVue=null;
/**
* panneau d'affichage d'une image generique associe au nom selectionne
*
*/
private ImageGeneriqueVue imageGeneriqueVue=null;
private MiniZoomImageVue mvz = null ;
private boolean importerObservations = false ;
 
private com.gwtext.client.widgets.Window fenetreCarto;
public boolean changementTabProg = false;
private InfosReferentielNom refTaxSelectionne = null;
 
private Panel centre;
/**
* constructeur privé (on accède a la classe par la méthode getInstance
*/
private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
{
this.carnetEnLigneMediateur=carnetEnLigneMediateur;
// on crée un modèle
observationModele = ObservationModele.Instance(this);
// initialisation du référentiel par défaut
setRefTaxSelectionne(Configuration.getReferentielsDispos().get(0));
listeObservation = new ListeObservationVue(this);
listeObservation.setTitle("Observations");
// quelques variables de position pour les borderlayouts
final BorderLayoutData regionNord = new BorderLayoutData(
RegionPosition.NORTH);
 
final BorderLayoutData regionCentre = new BorderLayoutData(
RegionPosition.CENTER);
regionCentre.setSplit(true);
 
final BorderLayoutData regionEst = new BorderLayoutData(
RegionPosition.EAST);
regionEst.setSplit(true);
 
final BorderLayoutData regionOuest = new BorderLayoutData(
RegionPosition.WEST);
regionOuest.setSplit(true);
panneauPrincipalObservation.setLayout(new BorderLayout()) ;
cartoObservationVue = new CartographieObservationVue(this);
cartoObservationVue.setLayout(new FitLayout());
// Le formulaire de saisie / modification d'observation
formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
formulaireSaisieObservationVue.setTitle("Saisie");
formulaireSaisieObservationVue.setTitleCollapse(true);
formulaireSaisieObservationVue.setCollapsible(true) ;
formulaireSaisieObservationVue.setAutoScroll(true) ;
fenetreCarto = new com.gwtext.client.widgets.Window();
fenetreCarto.setConstrain(true);
fenetreCarto.setModal(true);
fenetreCarto.add(cartoObservationVue);
formulaireSaisieObservationVue.addListener(
new PanelListenerAdapter() {
@Override
public void onCollapse(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onExpand(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
});
centre = new Panel();
centre.setLayout(new BorderLayout());
centre.setAutoScroll(true);
centre.setBorder(false);
centre.addListener(
new PanelListenerAdapter() {
@Override
public void onCollapse(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onExpand(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onResize(BoxComponent component, int adjWidth,
int adjHeight, int rawWidth, int rawHeight) {
formulaireSaisieObservationVue.redimensionnerFormulaire();
listeObservation.doLayout();
}
@Override
public void onAfterLayout(Container self) {
}
});
formulaireSaisieObservationVue.setBorder(false);
BorderLayoutData listeLayoutData = new BorderLayoutData(RegionPosition.SOUTH);
listeLayoutData.setSplit(true);
BorderLayoutData formLayoutData = new BorderLayoutData(RegionPosition.CENTER);
formLayoutData.setSplit(true);
centre.add(listeObservation, listeLayoutData);
centre.add(formulaireSaisieObservationVue, formLayoutData);
 
// Redimensionnement global sur collapse/expand
details.addListener(
new PanelListenerAdapter() {
@Override
public void onCollapse(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onExpand(Panel panel) {
String[] selectionListe = listeObservation.getIdSelectionnees();
if(selectionListe.length > 0) {
Observation obs = listeObservation.getCacheListeObservation().get(selectionListe[0]);
obtenirImageInformationExternes(obs.getCodeCourtReferentielTaxo(), obs.getNumeroNomenclaturalSaisi());
}
CarnetEnLigneMediateur.fireResize();
}
});
// on initialise le volet qui contient les details
details.setWidth("10%");
details.setTitleCollapse(true);
details.setCollapsible(true);
details.setAutoScroll(true);
details.setLayout(new RowLayout());
// Lien vers eflore
liExtVue = new LienExterneVue(this);
liExtVue.setHeight("20px");
details.add(liExtVue);
// Information de repartition
informationRepartitionVue=new InformationRepartitionVue(this);
details.add(informationRepartitionVue, new RowLayoutData("30%"));
// Image generique
imageGeneriqueVue=new ImageGeneriqueVue(this);
details.add(imageGeneriqueVue, new RowLayoutData("30%"));
mvz = new MiniZoomImageVue(this) ;
details.add(mvz, new RowLayoutData("34%")) ;
// on crée le panneau des filtres
filtres = new PanneauFiltresObservationVues(this);
// on initialise le volet qui contient les filtres
filtres.setWidth("10%");
filtres.setTitleCollapse(true);
filtres.setCollapsible(true);
filtres.addListener(
new PanelListenerAdapter() {
@Override
public void onCollapse(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onExpand(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
});
panneauPrincipalObservation.add(details,regionEst);
panneauPrincipalObservation.add(filtres,regionOuest);
panneauPrincipalObservation.add(centre,regionCentre);
}
/**
* Retourne une instance de manière unique
* @return l'instance unique du médiateur
*/
public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur)
{
if(!estInstancie || thisMediateur == null)
{
estInstancie = true ;
thisMediateur = new ObservationMediateur(carnetEnLigneMediateur) ;
}
return thisMediateur ;
}
public void connecterUtilisateur() {
if(importerObservations) {
observationModele.importerObservations();
}
if(panneauPrincipalObservation == null || !panneauPrincipalObservation.isCreated())
{
panneauPrincipalObservation.addListener(new ContainerListenerAdapter()
{
@Override
public void onRender(Component c)
{
panneauPrincipalObservation.purgeListeners() ;
initialiserArbres();
filtres.getRechercheLibreVue().raz();
obtenirNombreObservation();
analyserHistorique();
}
}) ;
}
else
{
initialiserArbres();
filtres.getRechercheLibreVue().raz();
obtenirNombreObservation();
analyserHistorique();
}
}
private void initialiserArbres() {
getPanneauFiltres().getArbreDateObservationFiltreVue().initialiser();
getPanneauFiltres().getArbreEntiteGeographiqueObservationFiltreVue().initialiser();
getPanneauFiltres().getArbreMotsClesObservationVue().initialiser();
}
 
// ACTIONS a entreprendre lors d'un evenement particulier
/**
* Lors du raffraichissement de la liste d'observation
*/
public void onRafraichissementListeObservations() {
carnetEnLigneMediateur.donneesObsVersImages(listeObservation.getCacheListeObservation());
observationModele.rafraichirCacheObservation(listeObservation.getCacheListeObservation());
filtres.getArbreMotsClesObservationVue().cocherMotsCles(new String[0]);
}
/**
*
* TODO : fonction plus generique, appelle sur un clic ou une selection de ligne, a appeller : SelectionnerObservation
* est appelé lors d'un clic de souris sur un enregistrement de la liste le
* médiateur gère alors les conséquences
*
* @param rowIndex
* le numéro de ligne selectionné
*/
public void onClicListeObservation(int rowIndex, String ordreObservation) {
Observation obs = obtenirCacheObservation().get(ordreObservation) ;
if(GWT.isScript()) {
masquerChargementInfosObservations() ;
}
if(formulaireSaisieObservationVue.getModification()) {
String[] ids = listeObservation.getIdSelectionnees();
if(ids.length > 1) {
formulaireSaisieObservationVue.setMasseModification(true);
ListeObservation listeObs = new ListeObservation();
for(int i=0; i < ids.length;i++) {
Observation obsAjout = observationModele.getCacheObservation().get(ids[i]);
listeObs.ajouterObservation(obsAjout);
}
formulaireSaisieObservationVue.rafraichir(listeObs, false);
} else {
formulaireSaisieObservationVue.setMasseModification(false);
// affichage des détails dans le formulaire d'observation
formulaireSaisieObservationVue.rafraichir(obs, false) ;
}
} else {
formulaireSaisieObservationVue.rafraichir(obs, false) ;
}
// Affichage de l'image correspondante
if(details.isVisible()) {
// Affichage de la carte de repartition correspondante
String numeroNomenclaturalSaisiObservation = obs.getNumeroNomenclaturalRetenu() ;
if(numeroNomenclaturalSaisiObservation != null && !numeroNomenclaturalSaisiObservation.isEmpty()) {
observationModele.obtenirImageInformationRepartition(informationRepartitionVue,obs.getCodeCourtReferentielTaxo(), numeroNomenclaturalSaisiObservation) ;
liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false);
observationModele.obtenirImageGenerique(imageGeneriqueVue,obs.getCodeCourtReferentielTaxo(), numeroNomenclaturalSaisiObservation) ;
observationModele.obtenirLiaisonImage(mvz, obs.getId()) ;
 
}
}
filtres.getArbreMotsClesObservationVue().rafraichir(obs.getMotsCles(), false);
}
public void obtenirImageInformationExternes(String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
if(details.isVisible()) {
if(GWT.isScript()) {
masquerChargementInfosObservations() ;
}
liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false);
observationModele.obtenirImageInformationRepartition(informationRepartitionVue, referentielTaxo, numeroNomenclaturalSaisiObservation) ;
observationModele.obtenirImageGenerique(imageGeneriqueVue, referentielTaxo, numeroNomenclaturalSaisiObservation) ;
}
}
public int getTaillePage() {
return listeObservation.getTaillePage();
}
public int getPageEnCours() {
return listeObservation.getPageEncours();
}
// ACCES au Modèle
// C du CRUD
/**
* TODO : afficher un message du type "observation ajouté".
* Lance la creation d'une observation
* @param obs : l'observation saisie
*/
public void ajouterObservation(Observation obs) {
// On rafraichit la liste d'observation
observationModele.ajouterObservation(listeObservation, obs) ;
filtres.getArbreEntiteGeographiqueObservationFiltreVue().rafraichir(obs,true) ;
filtres.getArbreDateObservationFiltreVue().rafraichir(obs,true) ;
}
// R du CRUD
/**
* Demande au modele le nombre d'Observation à afficher
* TODO : grouper cette demande avec la demande d'affichage de liste ?
*/
 
public void obtenirNombreObservation() {
listeObservation.masquerChargement() ;
mvz.raz() ;
imageGeneriqueVue.raz() ;
informationRepartitionVue.raz() ;
observationModele.obtenirNombreObservation(listeObservation) ;
}
/**
* Demande au modele le nombre d'Observation à afficher
* TODO : grouper cette demande avec la demande d'affichage de liste ?
*/
 
public void obtenirDernierePageObservation() {
listeObservation.rafraichir(new Observation(),false) ;
}
 
public void obtenirListeObservation() {
obtenirListeObservation(listeObservation);
}
/**
* Demande au modele le detail des Observations à afficher
* TODO : grouper cette demande avec la demande d'affichage de liste ?
*/
 
public void obtenirListeObservation(Rafraichissable r) {
listeObservation.masquerChargement() ;
observationModele.obtenirListeObservation(r,listeObservation.getTaillePage(),listeObservation.getPageEncours()) ;
}
public void obtenirCacheObservation(Rafraichissable r) {
r.rafraichir(observationModele.getCacheObservation(), false) ;
}
 
/**
* Envoie au modèle une demande pour obtenir l'arbre des localites
*
* @param r
* le raffraichissable qui a demandé la mise à jour
*/
public void obtenirListeEntiteGeographique() {
observationModele.obtenirListeEntiteGeographique(filtres.getArbreEntiteGeographiqueObservationFiltreVue());
}
// U du CRUD
public void modifierObservation(Observation obs) {
// On prend soin de récupérer les mots clés de l'observation
Observation obsMod = obtenirCacheObservation().get(obs.getNumeroOrdre());
obs.setMotsCles(obsMod.getMotsCles());
// On rafraichit la liste d'observation
observationModele.modifierObservation(listeObservation, obs) ;
filtres.getArbreEntiteGeographiqueObservationFiltreVue().rafraichir(obs,true) ;
filtres.getArbreDateObservationFiltreVue().rafraichir(obs,true) ;
}
public void modifierObservationEnMasse(Observation obs) {
// On rafraichit la liste d'observation
listeObservation.masquerChargement();
observationModele.modifierObservationEnMasse(listeObservation, obs) ;
}
// D du CRUD
/**
* TODO : afficher un message du type "observation modifie".
* Lance la modification d'une observation
* @param obs : l'observation a modifier
*/
public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
if(listeObservation.getSelectionModel().getCount() > 0)
{
if(Window.confirm("Êtes vous sur de vouloir supprimer cette observation ?")) {
observationModele.supprimerObservation(r,numeroOrdre) ;
}
}
}
public boolean listeAvoirObservations() {
return listeObservation.getStore().getCount() > 0;
}
// Assistants de saisie
/**
*
* Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
observationModele.obtenirListeReferentielCommune(r,critere) ;
}
// Assistants de saisie
/**
*
* Lance un appel de recherche d'une liste de résultats
* correspondant aux criteres de selections pour un référentiel donné
* @param r : la vue demandeuse de donnee
* @param referentiel : le référentiel demandé
* @param critere : les criteres de selection
*/
public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) {
observationModele.obtenirListeReferentielPerso(r, referentiel, critere) ;
}
/**
*
* Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void obtenirListeReferentielNom(Rafraichissable r,String referentiel, String critere) {
 
observationModele.obtenirListeReferentielNom(r, referentiel, critere) ;
}
// Etat du syteme
/**
* C'est dans cette fonction que doivent être renvoyé les valeurs des filtres
* sous forme de tableau [nom, valeur]
* @return Les noms et valeurs des filtres
*/
public String[][] renvoyerFiltres()
{
int longueur = 0;
String[] filtresEntitesGeo = filtres.getArbreEntiteGeographiqueObservationFiltreVue().renvoyerValeursAFiltrer() ;
String chaineNomsFiltresGeo = filtresEntitesGeo[0] ;
String chaineValFiltresGeo = filtresEntitesGeo[1] ;
String[] filtresDate = filtres.getArbreDateObservationFiltreVue().renvoyerValeursAFiltrer() ;
String chaineNomsFiltresDate = filtresDate[0] ;
String chaineValFiltresDate = filtresDate[1] ;
String[] filtresTaxon = filtres.getRechercheLibreVue().renvoyerValeursAFiltrer();
String[] filtresMotsCles = filtres.getArbreMotsClesObservationVue().renvoyerValeursAFiltrer();
String chaineNomsFiltres = "" ;
String chaineValFiltres = "" ;
if(!chaineNomsFiltresGeo.trim().equals("") && !chaineValFiltresGeo.trim().equals("")) {
chaineNomsFiltres += chaineNomsFiltresGeo+",";
chaineValFiltres += chaineValFiltresGeo+",";
}
if(!chaineNomsFiltresDate.trim().equals("") && !chaineValFiltresDate.trim().equals("")) {
chaineNomsFiltres += chaineNomsFiltresDate+",";
chaineValFiltres += chaineValFiltresDate+",";
}
if(!filtresTaxon[0].trim().equals("") && !filtresTaxon[1].trim().equals("")) {
chaineNomsFiltres += filtresTaxon[0]+",";
chaineValFiltres += filtresTaxon[1]+",";
}
if(!filtresMotsCles[0].trim().equals("") && !filtresMotsCles[1].trim().equals("")) {
chaineNomsFiltres += filtresMotsCles[0];
chaineValFiltres += filtresMotsCles[1];
}
String[] nomsFiltres = chaineNomsFiltres.split(",") ;
String[] valsFiltres = chaineValFiltres.split(",") ;
longueur += nomsFiltres.length;
String [][] valeursFiltres = new String[longueur][2] ;
int i = 0;
if(valsFiltres.length > 0)
{
for(i = 0 ; i < nomsFiltres.length ; i++)
{
valeursFiltres[i][0] = nomsFiltres[i] ;
if(valsFiltres[i].equals("Inconnue"))
{
valeursFiltres[i][1] = "NULL" ;
}
else
{
valeursFiltres[i][1] = valsFiltres[i] ;
}
}
}
listeObservation.afficherFiltres(valeursFiltres) ;
return valeursFiltres ;
}
 
/**
*
* @return
*
*/
public Panel getPanneauPrincipalObservation() {
return panneauPrincipalObservation;
}
 
 
public void montrerContextMenu(EventObject e) {
MenuObservationVue mvo = new MenuObservationVue(this) ;
mvo.showAt(e.getXY()) ;
}
 
public void doubleClicListeObservation(int rowIndex) {
}
// Getters
public PanneauFiltresObservationVues getPanneauFiltres() {
return filtres;
}
public void masquerChargementInfosObservations()
{
ExtElement masked = Ext.get(details.getId());
 
if (details.isVisible() && masked != null) {
informationRepartitionVue.raz() ;
imageGeneriqueVue.raz() ;
masked.mask("Chargement", true);
}
 
cartoObservationVue.masquerChargement(true);
}
public void deMasquerChargementInfosObservations()
{
ExtElement masked = Ext.get(details.getId());
 
if (details.isVisible() && masked != null) {
masked.unmask() ;
}
}
 
 
public void obtenirDatesObservation() {
observationModele.obtenirDatesObservation(filtres.getArbreDateObservationFiltreVue()) ;
}
 
 
public void exporterObservations() {
observationModele.exporterObservations() ;
}
 
 
public void deconnecterUtilisateur() {
if(panneauPrincipalObservation == null || panneauPrincipalObservation.isCreated() || !panneauPrincipalObservation.isVisible())
{
panneauPrincipalObservation.addListener(new ContainerListenerAdapter()
{
@Override
public void onShow(Component component)
{
deconnecterUtilisateur();
panneauPrincipalObservation.purgeListeners();
}
});
}
else
{
listeObservation.raz() ;
formulaireSaisieObservationVue.raz() ;
razFiltres();
informationRepartitionVue.raz() ;
imageGeneriqueVue.raz() ;
mvz.raz() ;
}
}
 
 
public void supprimerLiaisonObsImage() {
String ordreObs = listeObservation.getIdSelectionnees()[0];
String idObs = observationModele.getIdPourOrdreObs(ordreObs);
String idImg = mvz.getIdImage() ;
if(Window.confirm("Supprimer le lien entre l'image "+idImg+" et l'observations "+idObs+" ?"))
{
mvz.supprimerLiaisonImage() ;
observationModele.supprimerLiaisonImages(idImg,idObs) ;
}
}
 
public void supprimerObservations() {
if(listeObservation.getIdSelectionnees().length > 0) {
if(Window.confirm("Êtes vous sur de vouloir supprimer les observations sélectionnées ?")) {
String[] numObs = listeObservation.getIdSelectionnees();
String numObsapl = "" ;
for(int i = 0 ; i < numObs.length ; i++) {
numObsapl += numObs[i]+"," ;
}
observationModele.supprimerListeObservation(listeObservation,numObsapl) ;
}
}
else
{
Window.alert("Aucune observation sélectionnée");
}
}
 
 
public void transmettreObservations(boolean publier) {
if(Utilisateur.getInstance().isIdentifie()) {
if(listeObservation.getIdSelectionnees().length > 0) {
String action = "" ;
if(publier) {
action = "rendre publiques" ;
}
else {
action = "rendre privées" ;
}
if(Window.confirm("Êtes vous sur de vouloir "+action+" les observations sélectionnées ?")) {
String[] numObs = listeObservation.getIdSelectionnees();
String numObsApl = "" ;
for(int i = 0 ; i < numObs.length ; i++) {
numObsApl += numObs[i] ;
if(i != numObs.length - 1) {
numObsApl +="," ;
}
}
observationModele.transmettreListeObservation(listeObservation,numObsApl, publier) ;
}
}
else
{
Window.alert("Aucune observation sélectionnée");
}
}
else
{
if(publier) {
if(Window.confirm("La publication des observations nécessite d'être identifié, voulez-vous vous identifier ? (toutes vos observations saisies seront conservées)")) {
importerObservations = true ;
carnetEnLigneMediateur.afficherDialogueConnexion();
}
}
}
}
public void analyserHistorique() {
if (History.getToken().length()>0) {
 
final String anum=History.getToken();
observationModele.analyserHistorique(formulaireSaisieObservationVue,anum);
}
}
 
/**
* Appelle le modèle pour mettre à jour la paire mot-clé / identifiant du
* mot clé
*
* @param text
* le texte du mot clé
* @param id
* l'identifiant du mot clé
*/
public void mettreAjourMotsClesId(String text, String id) {
 
observationModele.mettreAjourMotsClesId(text, id);
 
}
public boolean gererDDObsSurMotCle(TreeNode NoeudMotCle, DragData dragData) {
if(dragData instanceof GridDragData) {
 
GridDragData gdd = ((GridDragData)dragData);
String idMotCle = ((String[])NoeudMotCle.getUserObject())[1];
Record[] obsALier = gdd.getSelections();
String idObsALier[] = new String[obsALier.length];
String idObsALierString = "";
for(int i = 0; i < obsALier.length; i++) {
if(i != 0) {
idObsALierString += ", ";
}
idObsALierString += obsALier[i].getAsString("ordre_observation");
if(!observationAvoirMotCle(idMotCle, obsALier[i].getAsString("ordre_observation"))) {
idObsALier[i] = obsALier[i].getAsString("ordre_observation");
} else {
idObsALier[i] = "";
}
}
String message = "Lier les observations ";
if(idObsALier.length == 1) {
message = "Lier l'observation ";
}
if(Window.confirm(message+idObsALierString+" au projet "+NoeudMotCle.getText()+" ?")) {
mettreAjourMotsCles(idMotCle, idObsALier);
return true;
} else {
return false;
}
} else {
return false;
}
}
public void gererDDMotCleSurObs(String idObs, String idMC) {
Observation obs = obtenirCacheObservation().get(idObs);
if(obs == null) {
return;
}
if(observationAvoirMotCle(idMC, idObs)) {
if(Window.confirm("Voulez vous supprimer la liaison entre l'observation et le mot clé ?")) {
String nouveauMotsCles = obs.getMotsCles().replace(idMC, "");
nouveauMotsCles = nouveauMotsCles.replace(";;", ";");
obs.setMotsCles(nouveauMotsCles);
observationModele.supprimerLiaisonMotCleObservations(listeObservation, obs.getId(), idMC);
}
}
}
 
public String gererOverDDMotCleSurObs(String idObs, String IdMC) {
if(observationAvoirMotCle(IdMC, idObs)) {
return "x-dd-drop-unlink";
} else {
return "x-dd-drop-nodrop";
}
}
/**
* Récupère les identifiants des obs selectionnézs et appelle le modèle
* pour qu'il mette à jour les associations mots clés/obs
*
* @param motsClesEnCours
* les mots clés à associer aux images selectionnés séparés par
* un ';'
* @param arbreMC
* l'arbre des mots clés à mettre à jour
*/
public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) {
String[] ids = listeObservation.getIdSelectionnees();
observationModele.mettreAjourMotsCles(motsClesEnCours, idsObsALier);
 
}
 
/**
* Appelle le médiateur pour qu'il ajoute un mot clé dans l'arbre des mots
* clés
*
* @param n
* le noeud à ajouter à l'arbre
* @param arbreMC
* le nouvel arbre de mots clés à mettre à jour
*/
public void ajouterMotCleDansArbre(TreeNode n, Tree arbreMC) {
observationModele.ajouterMotCleDansArbre(n, arbreMC);
getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n, false);
 
}
 
/**
* Appelle le médiateur pour qu'il supprime un mot clé et son sous arbre
* dans l'arbre des mots clés
*
* @param n
* le noeud à supprimer
* @param arbreMC
* le nouvel arbre de mots clés à mettre à jour
*/
public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
observationModele.supprimerMotCleDansArbre(n, arbreMC);
getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n.getId(), false);
 
}
 
/**
* Appelle le médiateur pour qu'il modifie un mot clé dans l'arbre des mots
* clés
*
* @param n
* le noeud à modifier
* @param arbreMC
* le nouvel arbre de mots clés à mettre à jour
*/
public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
observationModele.modifierMotCleDansArbre(n, arbreMC);
getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n, false);
 
}
 
/**
* Appelle le médiateur pour qu'il déplace un mot clé et son sous arbre dans
* l'arbre des mots clés
*
* @param n
* le noeud à déplacer
* @param arbreMC
* le nouvel arbre de mots clés à mettre à jour
*/
public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
observationModele.deplacerMotCleDansArbre(n, arbreMC);
}
 
 
public void rafraichirArbreMotsCles(Tree arbreMotsCles) {
getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(arbreMotsCles, false);
}
public boolean observationAvoirMotCle(String idMotCle, String idObs) {
Observation obs = obtenirCacheObservation().get(idObs);
if(obs == null) {
return false;
}
if(obs.getMotsCles().contains(idMotCle)) {
return true;
}
return false;
}
 
 
public void obtenirArbreMotsCles(Rafraichissable r) {
observationModele.obtenirArbreMotsCles(r);
}
public String[] obtenirTexteMotsCles(String[] idsMotsCles) {
String[] tableauMotsClesTexte = new String[idsMotsCles.length];
for(int i=0; i< idsMotsCles.length; i++) {
tableauMotsClesTexte[i] = observationModele.obtenirTexteMotCle(idsMotsCles[i]);
}
return tableauMotsClesTexte;
}
public ListeObservation obtenirCacheObservation() {
return observationModele.getCacheObservation();
}
 
public void donneesExterieures(Object nouvelleDonnees) {
if(nouvelleDonnees instanceof Tree) {
Tree arbreMotsCles = (Tree)nouvelleDonnees ;
observationModele.rafraichirArbreMotsCles(nouvelleDonnees);
rafraichirArbreMotsCles(arbreMotsCles);
}
}
public void transmettreDonnees(Object o) {
carnetEnLigneMediateur.donneesObsVersImages(o);
}
 
public void onModeModification() {
String[] ids = listeObservation.getIdSelectionnees();
Observation obs = listeObservation.getCacheListeObservation().get(ids[ids.length - 1]);
if(ids.length > 1) {
formulaireSaisieObservationVue.setMasseModification(true);
ListeObservation listeObs = new ListeObservation();
for(int i=0; i < ids.length;i++) {
Observation obsAjout = observationModele.getCacheObservation().get(ids[i]);
listeObs.ajouterObservation(obsAjout);
}
formulaireSaisieObservationVue.rafraichir(listeObs, false);
} else {
formulaireSaisieObservationVue.setMasseModification(false);
// affichage des détails dans le formulaire d'observation
formulaireSaisieObservationVue.rafraichir(obs, false) ;
}
formulaireSaisieObservationVue.setTitle("Modification");
}
public void onModeCreation() {
formulaireSaisieObservationVue.setTitle("Création");
String[] ids = listeObservation.getIdSelectionnees();
if(ids.length > 1) {
Observation obs = listeObservation.getCacheListeObservation().get(ids[ids.length - 1]);
// affichage des détails dans le formulaire d'observation
formulaireSaisieObservationVue.rafraichir(obs, false) ;
}
}
 
public void obtenirInformationCoord(Rafraichissable r, LatLng coord) {
observationModele.obtenirInformationCoord(r,coord);
}
public void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) {
observationModele.obtenirInformationCommune(r,nomCommune, codePostal);
}
 
public void obtenirInformationCoord(LatLng coord) {
observationModele.obtenirInformationCoord(cartoObservationVue,coord);
}
 
public void obtenirInformationCommune(String nomCommune,
String codePostal) {
observationModele.obtenirInformationCommune(cartoObservationVue,nomCommune, codePostal);
}
 
public void rafraichirSaisieCommuneObservation(EntiteGeographiqueObservation infosCommune) {
formulaireSaisieObservationVue.rafraichir(infosCommune, false);
cacherFenetreCarto();
}
 
private void razFiltres() {
filtres.getArbreDateObservationFiltreVue().raz() ;
filtres.getArbreEntiteGeographiqueObservationFiltreVue().raz() ;
filtres.getArbreMotsClesObservationVue().raz();
filtres.getRechercheLibreVue().raz();
}
 
public void viderFiltre(String nom) {
filtres.viderFiltres(nom);
obtenirNombreObservation();
}
 
public Component getListeObservation() {
return listeObservation;
}
 
public void redimensionnerPanneaux(int adjHeight, int adjWidth) {
formulaireSaisieObservationVue.setHeight(300);
listeObservation.setHeight(adjHeight/2);
centre.doLayout();
}
 
public void afficherFormulaireImportObservation() {
if (formImportObs==null) { // lazy inst.
formImportObs = new FormulaireImportObservationVue(this);
}
formImportObs.afficher();
}
 
public void setImporterObservationsAnonymes(boolean importerObservations) {
this.importerObservations = importerObservations;
}
 
private void localiserSurCommuneSelectionnee() {
cartoObservationVue.masquerChargement(true);
double[] coordsTab = formulaireSaisieObservationVue.coordonneesValides();
if(formulaireSaisieObservationVue.coordonneesValides() != null && !formulaireSaisieObservationVue.getCommune().equals("")) {
String nomCommune = formulaireSaisieObservationVue.getCommuneSansDepartement();
String dptCommune = formulaireSaisieObservationVue.getDepartement();
EntiteGeographiqueObservation egeo = new EntiteGeographiqueObservation(dptCommune, nomCommune, "","");
egeo.setLat(coordsTab[0]+"");
egeo.setLon(coordsTab[1]+"");
cartoObservationVue.rafraichir(egeo, false);
} else {
if(formulaireSaisieObservationVue.coordonneesValides() != null) {
LatLng coords = LatLng.newInstance(coordsTab[0],coordsTab[1]);
obtenirInformationCoord(coords);
} else if (formulaireSaisieObservationVue.communeInitialisee()) {
String nomCommune = formulaireSaisieObservationVue.getCommune();
String dptCommune = formulaireSaisieObservationVue.getDepartement();
obtenirInformationCommune(nomCommune, dptCommune);
} else {
obtenirInformationCoord(cartoObservationVue.getCentreFrance());
}
}
}
 
public void afficherFenetreCarto() {
int hauteur = (int)Math.round(Window.getClientHeight()*0.75);
int largeur = (int)Math.round(Window.getClientWidth()*0.75);
fenetreCarto.setSize(largeur, hauteur);
if(!fenetreCarto.isVisible()) {
fenetreCarto.show();
}
cartoObservationVue.setTailleCarte(hauteur - 20, largeur - 20);
cartoObservationVue.recentrerCarte();
}
 
private void cacherFenetreCarto() {
if(fenetreCarto.isVisible()) {
fenetreCarto.hide();
}
}
 
public InfosReferentielNom getRefTaxSelectionne() {
return refTaxSelectionne;
}
public void setRefTaxSelectionne(int index) {
refTaxSelectionne = Configuration.getReferentielsDispos().get(index);
}
public void setRefTaxSelectionne(InfosReferentielNom refTax) {
refTaxSelectionne = refTax;
}
}
/branches/v1.6-croc/src/org/tela_botanica/client/observation/ObservationModele.java
New file
0,0 → 1,729
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 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, 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è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, 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);
}
 
@Override
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("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é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 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());
}
}