WebSVN – eFlore/Applications.cel – Diff – /branches/v1.6-croc/src/org/tela_botanica/client/observation/ObservationMediateur.java


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.EntiteGeographiqueObservation;
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 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);
		
	
		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.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.getNumeroNomenclaturalSaisi() ;
			observationModele.obtenirImageInformationRepartition(informationRepartitionVue,numeroNomenclaturalSaisiObservation) ;
			liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false);
			observationModele.obtenirImageGenerique(imageGeneriqueVue,numeroNomenclaturalSaisiObservation) ;
			observationModele.obtenirLiaisonImage(mvz, obs.getId()) ;
		}
		
		filtres.getArbreMotsClesObservationVue().rafraichir(obs.getMotsCles(), false);
	}
	
	public void obtenirImageInformationExternes(String numeroNomenclaturalSaisiObservation) {
		
		if(details.isVisible()) {
			if(GWT.isScript()) {
				masquerChargementInfosObservations() ;
			}
			liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false);
			observationModele.obtenirImageInformationRepartition(informationRepartitionVue,numeroNomenclaturalSaisiObservation) ;
			observationModele.obtenirImageGenerique(imageGeneriqueVue,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 critere) {
 
		observationModele.obtenirListeReferentielNom(r,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] = "000null" ;
				}
				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);
		
		//if(listeObservation.getHeight() > centre.getHeight()) {
			listeObservation.setHeight(adjHeight/2);
		//}
		centre.doLayout();
		
	}
 
	public void afficherFormulaireImportObservation() {
		if (formImportObs==null) { // lazy inst. 
			formImportObs = new FormulaireImportObservationVue(this);
		}
		formImportObs.initialiserUtilisateur(Utilisateur.getInstance().getIdentifiantUtilisateurConnecte());
		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();
		}
	}
}

Subversion Repositories eFlore/Applications.cel

(root)/branches/v1.6-croc/src/org/tela_botanica/client/observation/ObservationMediateur.java @ 3220 – Rev 1291 → 1314

Rev 1291		Rev 1314
1	`package org.tela_botanica.client.observation;`	1	`package org.tela_botanica.client.observation;`
2		2
3		3
4		4
5	`// TODO : systematiser les onQuelquechose, appelle depuis les vues`	5	`// TODO : systematiser les onQuelquechose, appelle depuis les vues`
6	`import org.tela_botanica.client.CarnetEnLigneMediateur;`	6	`import org.tela_botanica.client.CarnetEnLigneMediateur;`
7	`import org.tela_botanica.client.interfaces.Rafraichissable;`	7	`import org.tela_botanica.client.interfaces.Rafraichissable;`
8	`import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;`	8	`import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;`
9	`import org.tela_botanica.client.modeles.objets.ListeObservation;`	9	`import org.tela_botanica.client.modeles.objets.ListeObservation;`
10	`import org.tela_botanica.client.modeles.objets.Observation;`	10	`import org.tela_botanica.client.modeles.objets.Observation;`
11	`import org.tela_botanica.client.modeles.objets.Utilisateur;`	11	`import org.tela_botanica.client.modeles.objets.Utilisateur;`
12	`import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;`	12	`import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;`
13	`import org.tela_botanica.client.vues.observation.CartographieObservationVue;`	13	`import org.tela_botanica.client.vues.observation.CartographieObservationVue;`
14	`import org.tela_botanica.client.vues.observation.FormulaireImportObservationVue;`	14	`import org.tela_botanica.client.vues.observation.FormulaireImportObservationVue;`
15	`import org.tela_botanica.client.vues.observation.FormulaireSaisieObservationVue;`	15	`import org.tela_botanica.client.vues.observation.FormulaireSaisieObservationVue;`
16	`import org.tela_botanica.client.vues.observation.ListeObservationVue;`	16	`import org.tela_botanica.client.vues.observation.ListeObservationVue;`
17	`import org.tela_botanica.client.vues.observation.MenuObservationVue;`	17	`import org.tela_botanica.client.vues.observation.MenuObservationVue;`
18	`import org.tela_botanica.client.vues.observation.PanneauFiltresObservationVues;`	18	`import org.tela_botanica.client.vues.observation.PanneauFiltresObservationVues;`
19	`import org.tela_botanica.client.vues.observation.indicateurs.ImageGeneriqueVue;`	19	`import org.tela_botanica.client.vues.observation.indicateurs.ImageGeneriqueVue;`
20	`import org.tela_botanica.client.vues.observation.indicateurs.InformationRepartitionVue;`	20	`import org.tela_botanica.client.vues.observation.indicateurs.InformationRepartitionVue;`
21	`import org.tela_botanica.client.vues.observation.indicateurs.LienExterneVue;`	21	`import org.tela_botanica.client.vues.observation.indicateurs.LienExterneVue;`
22	`import org.tela_botanica.client.vues.observation.indicateurs.MiniZoomImageVue;`	22	`import org.tela_botanica.client.vues.observation.indicateurs.MiniZoomImageVue;`
23		23
24	`import com.google.gwt.core.client.GWT;`	24	`import com.google.gwt.core.client.GWT;`
25	`import com.google.gwt.maps.client.geom.LatLng;`	25	`import com.google.gwt.maps.client.geom.LatLng;`
26	`import com.google.gwt.user.client.History;`	26	`import com.google.gwt.user.client.History;`
27	`import com.google.gwt.user.client.Window;`	27	`import com.google.gwt.user.client.Window;`
28	`import com.gwtext.client.core.EventObject;`	28	`import com.gwtext.client.core.EventObject;`
29	`import com.gwtext.client.core.Ext;`	29	`import com.gwtext.client.core.Ext;`
30	`import com.gwtext.client.core.ExtElement;`	30	`import com.gwtext.client.core.ExtElement;`
31	`import com.gwtext.client.core.RegionPosition;`	31	`import com.gwtext.client.core.RegionPosition;`
32	`import com.gwtext.client.data.Record;`	32	`import com.gwtext.client.data.Record;`
33	`import com.gwtext.client.data.Tree;`	33	`import com.gwtext.client.data.Tree;`
34	`import com.gwtext.client.dd.DragData;`	34	`import com.gwtext.client.dd.DragData;`
35	`import com.gwtext.client.widgets.BoxComponent;`	35	`import com.gwtext.client.widgets.BoxComponent;`
36	`import com.gwtext.client.widgets.Component;`	36	`import com.gwtext.client.widgets.Component;`
37	`import com.gwtext.client.widgets.Container;`	37	`import com.gwtext.client.widgets.Container;`
38	`import com.gwtext.client.widgets.Panel;`	38	`import com.gwtext.client.widgets.Panel;`
39	`import com.gwtext.client.widgets.event.ContainerListenerAdapter;`	39	`import com.gwtext.client.widgets.event.ContainerListenerAdapter;`
40	`import com.gwtext.client.widgets.event.PanelListenerAdapter;`	40	`import com.gwtext.client.widgets.event.PanelListenerAdapter;`