WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java


package org.tela_botanica.client.vues.observation;
 
 
import java.util.HashMap;
import java.util.Iterator;
 
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Ontologies;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.Util;
import org.tela_botanica.client.vues.BarrePaginationVue;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
 
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.SortDir;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.SortState;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragDropConfig;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Tool;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.event.GridHeaderListenerAdapter;
import com.gwtext.client.widgets.grid.event.GridListenerAdapter;
import com.gwtext.client.widgets.grid.event.GridRowListenerAdapter;
import com.gwtext.client.widgets.tree.TreeDragData;
import com.gwtext.client.widgets.tree.TreeNode;
 
/**
 * Liste d'observation composée de ligne d'observation
 * l'interface rafraichissable et l'interface vueListable
 * 
 * @author David Delon 2008
 */
public class ListeObservationVue extends GridPanel implements Rafraichissable,
		VueListable, ListePaginable {
 
	/**
	 * Le médiateur associé à la vue
	 */
	private ObservationMediateur	observationMediateur		= null;
 
	/**
	 * Config de colonne
	 */
	private ColumnConfig	etatObservation;
	private ColumnConfig	referentielTaxoObservation;
	private ColumnConfig	nomSaisiObservation;
	private ColumnConfig	nomRetenuObservation;
	private ColumnConfig	familleObservation;
	private ColumnConfig	lieuObservation;
	private ColumnConfig	altitudeObservation;
	private ColumnConfig	dateObservation;
	private ColumnConfig	ordreObservation;
	private ColumnConfig 	abondanceObservation;
	private ColumnConfig 	certitudeObservation;
	private ColumnModel		modeleColonnes;
 
	/**
	 * Store qui contient les données à afficher
	 */
	private Store			st				= null;
	/**
	 * Barre de pagination
	 */
	private BarrePaginationVue bt = null ;
	/**
	 * Numéro de page en cours
	 */
	private int pageEncours = 0 ;
	/**
	 * Nombre de pages totales
	 */
	private int pageMax = 1 ;
	/**
	 * Taille de page (par défaut 20)
	 */
	private int taillePage = 20 ;
	/**
	 * Nombre d'éléments total correspondant à la requete
	 */
	private int nbElements = 0 ;
	
	private ListeObservation cacheListeObservation = null;
	
	private Tool exporterObservations = null ;
	
	private final int KEY_ENTER = 13;
	
	private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION";
 
 
	private boolean tailleInitialisee = false ;
 
	private ColumnConfig phenologieObservation;
 
	private SortDir directionTri;
 
	private String champTri;
	
	private boolean triActif;
	
	/**
	 * Constructeur sans arguments (privé car ne doit pas être utilisé)
	 */
	@SuppressWarnings("unused")
	private ListeObservationVue()
	{
		super() ;
	}
	
	/**
	 * Constructeur avec argument
	 * @param im le médiateur à associer
	 */
	public ListeObservationVue(ObservationMediateur obs) {		
		
		this.observationMediateur = obs;
		
		setId("x-list-obs");
		
		setHeader(true);  
		// on place la barre de pagination
		bt = new BarrePaginationVue(this);		
		bt.setLabelElement("Observations");
		bt.setTaillePageParDefaut(20);
		bt.setIntervallesPages(new String[] {"1000","400","200","100","50","20","10"}) ;
		
		Toolbar barreActions = new Toolbar();
		ToolbarButton publier = new ToolbarButton("Rendre publiques");
		publier.addListener(new ButtonListenerAdapter() {
			@Override
			public void onClick(Button b, EventObject e) {
				observationMediateur.transmettreObservations(true);
			}
		});
		
		ToolbarButton privatiser = new ToolbarButton("Rendre privées");
		privatiser.addListener(new ButtonListenerAdapter() {
			@Override
			public void onClick(Button b, EventObject e) {
				observationMediateur.transmettreObservations(false);
			}
		});
		
		ToolbarButton supprimer = new ToolbarButton("Supprimer");
		supprimer.addListener(new ButtonListenerAdapter() {
			@Override
			public void onClick(Button b, EventObject e) {
				observationMediateur.supprimerObservations();
			}
		});
		
		ToolbarButton importer = new ToolbarButton("Importer");
		importer.addListener(new ButtonListenerAdapter() {
			@Override
			public void onClick(Button b, EventObject e) {
				observationMediateur.afficherFormulaireImportObservation();
			}
		});
		
		ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>");
		ToolbarTextItem exporterFull = new ToolbarTextItem("<a href=\"#\" id=\"lienExportFull\" title=\"Export des noms communs, des champs étendus, des données baseflor et des syntaxon baseveg\"> Export Étendu </a>");
 		ToolbarTextItem exporterPDF = new ToolbarTextItem("<a href=\"#\" id=\"lienExportPDF\" title=\"Génération d'étiquettes au format PDF pour la sélection\"> Étiquettes </a>");
		
		barreActions.addButton(publier);
		barreActions.addButton(privatiser);
		barreActions.addSpacer();
		barreActions.addButton(supprimer);
		barreActions.addSpacer();
		barreActions.addButton(importer);
		barreActions.addSpacer();
		barreActions.addItem(exporter);
		barreActions.addItem(exporterFull);
		barreActions.addItem(exporterPDF);
		
		this.setTopToolbar(barreActions) ;
		this.setBottomToolbar(bt);
		
		this.setCollapsible(true);
		this.setTitleCollapse(true);
 
		this.setTitle("Observations") ;
		
		modeleColonnes = new ColumnModel(getConfigColonnes());
		
		this.setColumnModel(modeleColonnes);
		
		this.setAutoScroll(true);
		this.setEnableColumnResize(true);
		
		// creation du store		
		RecordDef rd = new RecordDef(getDefinitionChamps());
		st = new Store(rd);
 
		// on associe le store
		
		this.setStore(st);
		this.getView().setAutoFill(true);
		this.getView().setForceFit(true) ;
				
		// on crée un masque de chargement qui s'affichera lors des mises à jour
		this.setLoadMask("Chargement");
	
		// on ajoute les listeners
		ajouterListeners();
		
		configDragAndDrop();
 
	}
	
	private ColumnConfig[] getConfigColonnes() {
		// on construit le modèle de colonnes
		// Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir) 
		Renderer colRend = new Renderer() {
 
			@Override
			public String render(Object value, CellMetadata cellMetadata,
					Record record, int rowIndex, int colNum, Store store) {
				
				String valeur = "";
				if(value != null && !value.equals("null") && !value.equals("000null") && !value.equals("0000-00-00 00:00:00")) {			
					valeur = value.toString() ;
				}
				return valeur;
			}
		} ;
		
		Renderer dateRend = new Renderer() {
 
			@Override
			public String render(Object value, CellMetadata cellMetadata,
					Record record, int rowIndex, int colNum, Store store) {
				
				if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {
				
					return "" ;
				}	
				else
				{
					String dateEntiere = value.toString() ;
					String[] dateEtHeure = dateEntiere.split(" ", 2);
					if(verifierFormatDate(dateEtHeure[0])) {
						String[] dateFormateeTab = dateEtHeure[0].split("-",3);
						return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ;
					}
				}
				
				return value.toString() ;
			}
			
		} ;
		
		etatObservation = new ColumnConfig("Transmis", "etat_observation", 20, true, new Renderer() {
 
			@Override
			public String render(Object value, CellMetadata cellMetadata,
					Record record, int rowIndex, int colNum, Store store) {
				if(value.equals("1"))
				{
					return "<img src=\"tela.png\"/></img>" ;
				}
				else
				{
					return "" ;
				}
			}
			
		});		
		
		referentielTaxoObservation = new ColumnConfig("Référentiel", "referentiel_taxo_observation", 15, true, colRend);
		nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 130, true, colRend);
		nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 130, true, colRend);
		familleObservation = new ColumnConfig("Famille", "famille_observation", 50, true, colRend);
		lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 130, true, colRend);
		altitudeObservation = new ColumnConfig("Alt", "altitude_observation", 10, true, colRend);
		dateObservation = new ColumnConfig("Date", "date_observation", 70, true, dateRend);
		abondanceObservation = new ColumnConfig("Abondance", "abondance", 50, true, colRend);
		certitudeObservation = new ColumnConfig("Identification", "certitude", 50, true, new Renderer() {
			@Override
			public String render(Object value, CellMetadata cellMetadata,
					Record record, int rowIndex, int colNum, Store store) {
				return Ontologies.getCorrespondanceCertitude(record.getAsString("certitude"));
			}
			
		});
		phenologieObservation = new ColumnConfig("Phénologie", "phenologie", 40, true, colRend);	
		ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 70, true, colRend);		
		ColumnConfig[] cm = {etatObservation, referentielTaxoObservation, 
							 nomSaisiObservation, certitudeObservation, 
							 nomRetenuObservation, familleObservation,
							 abondanceObservation, phenologieObservation,
							 lieuObservation, altitudeObservation,
							 dateObservation, ordreObservation};
	
		return cm;
	}
 
 
	/**
	 * Ajoute les listeners pour la gestion des évènements
	 */
	private void ajouterListeners() {
			
		this.addGridHeaderListener(new GridHeaderListenerAdapter() {		
			@Override
			public void onHeaderClick(GridPanel grid, int colIndex, EventObject e) {
				triActif = true;
				Timer t = new Timer() {
					
					@Override
					public void run() {
						enregistrerEtatTri();
						observationMediateur.obtenirListeObservation();
					}
				};
				t.schedule(200);
			}
		});
		
		this.addGridRowListener(new GridRowListenerAdapter() {
			
			// gestion du clic sur une ligne
			@Override
			public void onRowClick(GridPanel grid, int rowIndex,
					EventObject e) {
				// on notifie le médiateur et on lui passe le numéro de ligne
				
			
				Record rd = st.getAt(rowIndex);
				
				String ordreObservation = rd.getAsString("ordre_observation") ;
				observationMediateur.onClicListeObservation(rowIndex,ordreObservation);
				
			}
 
			// gestion du clic droit
			@Override
			public void onRowContextMenu(GridPanel grid, int rowIndex,
					EventObject e) {
				// on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu
				e.stopEvent() ;
				// on notifie le médiateur en lui passant l'évenement
				observationMediateur.montrerContextMenu(e);
			}
 
			// gestion du double clic
			@Override
			public void onRowDblClick(GridPanel grid, int rowIndex,
					EventObject e) {
				// on notifie le médiateur en lui passant le numéro de ligne
				observationMediateur.doubleClicListeObservation(rowIndex);
			}
			
		});
		
		this.addGridListener(new GridListenerAdapter() {
			@Override
			public void onKeyPress(EventObject e) {
				if(e.getKey() == KEY_ENTER) {
					Record rd = getSelectionModel().getSelected();
					int rowIndex = st.indexOf(rd);
					String ordreObservation = rd.getAsString("ordre_observation") ;
					observationMediateur.onClicListeObservation(rowIndex, ordreObservation);
				}
			}
		});
		
		this.addListener(new PanelListenerAdapter() {
			@Override
			public void onRender(Component c) {
				
				ExtElement lienExport = Ext.get("lienExport") ;
				lienExport.addListener("click", new EventCallback() {
					@Override
					public void execute(EventObject e) {
						observationMediateur.exporterObservations("xls", "standard");
					}
				});
 
				ExtElement lienExportFull = Ext.get("lienExportFull") ;
				lienExportFull.addListener("click", new EventCallback() {
					@Override
					public void execute(EventObject e) {
						observationMediateur.exporterObservations("xls", "standard,avance,etendu,baseflor");
					}
				});
 
				ExtElement lienExportPDF = Ext.get("lienExportPDF") ;
				lienExportPDF.addListener("click", new EventCallback() {
					@Override
					public void execute(EventObject e) {
						observationMediateur.exporterObservationsPDF();
					}
				});
			}
		});
		
		this.addListener(new PanelListenerAdapter() {
			@Override
			public void onBodyResize(Panel panel, java.lang.String width, java.lang.String height) {
				doLayout();
			}
		});
	}
	
	/**
	 * Configure le drag 'n drop pour la liste
	 */
	private void configDragAndDrop()
	{
 
		setDdGroup("ObsMotsClesGroup");
		setEnableDragDrop(true);
		setDragDropText("Glissez les observations sélectionnées sur un projet pour les lier");
		// on fabrique la nouvelle configuration
		// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
		DropTargetConfig dtc = new DropTargetConfig();
		dtc.setdDdGroup("ObsMotsClesGroup");
		dtc.setTarget(true);
		
		DragDropConfig ddc = new DragDropConfig();
 
		//La drop target permet de gérer l'évenement onDrop sur l'élement courant
		@SuppressWarnings("unused")
		DropTarget tg = new DropTarget(this, dtc)
		{
			@Override
			public boolean notifyDrop(DragSource source, EventObject e, DragData data){	
				
				// si on reçoit des données provenant d'un arbre
				// on les convertit 
				if(data instanceof TreeDragData)  {
			    	TreeDragData tdd = (TreeDragData)data ;
			    	
			    	TreeNode treeNode = tdd.getTreeNode();  
			    	String idMc = treeNode.getId();  
			    	
			    	int index = getView().findRowIndex(e);
			    	if(index < 0) {
			    		return true;
			    	}
			    	
			    	Record obsRd = getStore().getRecordAt(index);
			    	if(obsRd == null) {
			    		return true;
			    	}
			    	
			    	String ordreObs = obsRd.getAsString("ordre_observation");
			    	
			    	if(ordreObs != null) {
			    		observationMediateur.gererDDMotCleSurObs(ordreObs, idMc);
			    		return true ;
			    	} else {
			    		return true;
			    	}
				}
		    	return true;
			}
			
			@Override
			public String notifyOver(DragSource source, EventObject e, DragData data){
				
				if(data instanceof TreeDragData)  {
			    	TreeDragData tdd = (TreeDragData)data ;
			    	
			    	TreeNode treeNode = tdd.getTreeNode();  
			    	String idMc = treeNode.getId();  
			    	
			    	int index = getView().findRowIndex(e);
			    	if(index < 0) {
			    		return "x-dd-drop-nodrop";
			    	}
			    	
			    	Record obsRd = getStore().getRecordAt(index);
			    	
			    	if(obsRd == null) {
			    		return "x-dd-drop-nodrop";
			    	}
			    	
			    	String ordreObs = obsRd.getAsString("ordre_observation");
			    	
			    	if(ordreObs != null) {
			    		return observationMediateur.gererOverDDMotCleSurObs(ordreObs, idMc);
			    	}
				}
				
				return "x-dd-drop-nodrop";
			}
		};
	}
 
	/**
	 * Méthode héritée de l'interface VueListable
	 * Sélectionne les observations  dans la liste suivant les identifiants donnés en paramètres
	 */
	@Override
	public String[] getIdSelectionnees() {
		
		Record[] selection = this.getSelectionModel().getSelections();
		int taille = selection.length;
		String id_selection[] = new String[taille];
 
		for (int i = 0; i < selection.length; i++) {
 
			id_selection[i] = selection[i].getAsString("ordre_observation");
		}
 
		return id_selection;
	}
	
 
	
	/**
	 * Sélectionne des enregistrements donné 
	 * @param sel un tableau d'enregistrement à selectionner
	 */
	public void selectionnerEnregistrements(Record[] sel) {
 
			getSelectionModel().clearSelections();
			getSelectionModel().selectRecords(sel);
		
	}
	
	/**
	 * Accesseur pour la toolbar de pagination
	 * @return la toolbar de pagination
	 */
	public BarrePaginationVue getToolBarVue()
	{
		return bt ;
	}
 
 
	/**
	 * Recherche l'élement actuellement affiché et affiche son message de chargement
	 */
	public void masquerChargement()
	{
		ExtElement masked = Ext.get(getId()) ;
 
		if (masked!=null) {
			masked.mask("Chargement") ;
		}
	}
	
	/**
	 * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
	 */
	public void demasquerChargement()
	{
		ExtElement masked = Ext.get(getId()) ;
		
		if (masked!=null) {
			masked.unmask() ;
		}
	}
	
	/**
	 * Méthode héritée de l'interface rafraichissable
	 * @param nouvelleDonnees les nouvelles données
	 * @param repandreRafraichissement le booleen de notification du rafraichissement
	 */
	@Override
	public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
		// si l'on a reçu une liste d'observation
		if(nouvelleDonnees instanceof ListeObservation)
		{	
				ListeObservation data = (ListeObservation) nouvelleDonnees ;
				Object[][] observationData = new Object[data.size()][13];
				int i = 0 ;
				
				if(data.size() == 0)
				{
					pageEncours = 0 ;
				}
				
				// on la parse et on récupère les informations qui nous interessent
				for (Iterator it = data.keySet().iterator(); it.hasNext();) 
				{
					
					Observation obs=data.get(it.next());
					
					observationData[i][0] = obs.getTransmis();
					observationData[i][1] = obs.getCodeCourtReferentielTaxo();
					observationData[i][2] = obs.getNomSaisi();
					observationData[i][3] = obs.getCertitude();
					observationData[i][4] = obs.getNomRetenu();
					observationData[i][5] = obs.getFamille();
					observationData[i][6] = obs.getAbondance();
					observationData[i][7] = obs.getPhenologie();
					observationData[i][8] = Util.formaterLieu(obs, modeleLieu);
					observationData[i][9] = formaterAltitude(obs.getAltitude());
					observationData[i][10] = obs.getDate();
					observationData[i][11] = obs.getNumeroOrdre();		
					observationData[i][12] = obs.getNumeroNomenclaturalSaisi();
									
					i++ ;
				}
		
				RecordDef rd = new RecordDef(getDefinitionChamps());
				
				final MemoryProxy dataProxy = new MemoryProxy(observationData);
				final ArrayReader reader = new ArrayReader(rd);
		
				final Store observationStore = new Store(dataProxy, reader);
				
				st = observationStore ;
				st.load() ;
									
				// et on reconfigure et rafraichit la vue
				this.reconfigure(st, this.getColumnModel());
				demasquerChargement();
			    cacheListeObservation=data;
				observationMediateur.onRafraichissementListeObservations();	
		}
		
		// Si on reçoit un tableau d'entiers
		// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères
		if(nouvelleDonnees instanceof int[])
		{
			int[] pages = (int[])nouvelleDonnees ;
			
			// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
			pageMax  = calculerNbPages(pages[0]) ;
			nbElements = pages[0] ;
			
			
			// et on notifie de le mediateur du changement des valeurs
			changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
			
			if(nbElements > 0) {
				masquerChargement();
				observationMediateur.obtenirListeObservation(this);
			} else {
				this.rafraichir(new ListeObservation(0), false);
			}
		}
		
		
		// si l'on a reçu une Observation 
		if(nouvelleDonnees instanceof Observation) {
			// la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri
			// on l'enregistre donc avant suppression 
			enregistrerEtatTri();
			Observation obs= (Observation) nouvelleDonnees;
			if (obs.getNumeroOrdre()==null) { 
				
				// Nouvelle observation
				// On affiche la dernière page
				pageEncours = pageMax ;
				masquerChargement();
	
				observationMediateur.obtenirNombreObservation();
			
			}
			else { // Modification d'une observation
					
				masquerChargement();
				observationMediateur.obtenirNombreObservation();		
			}
		}
		
		// Si on a effectué une suppression
		if(nouvelleDonnees instanceof String)
		{
			// la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri
			// on l'enregistre donc avant suppression 
			enregistrerEtatTri();
			observationMediateur.obtenirNombreObservation() ;
		}
		
		if(!getTailleInitialisee()) {
			if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) {
				doLayout();
				setTailleInitialisee();
			}
		}
		
		// réaffectation du tri courant si nécessaire
		if(directionTri != null && champTri != null) {
			st.sort(champTri, directionTri);
		}
	}
	
	private String formaterAltitude(String alt) {
		String alfFmt = Util.formaterNombre(alt);
		if(!alfFmt.isEmpty() && !Util.estZero(alfFmt)) {
			alfFmt = alfFmt+" m.";
		}
		return alfFmt;
	}
	
	private FieldDef[] getDefinitionChamps() {
		// creation du store qui les contient
		FieldDef defEtatObservation = new StringFieldDef("etat_observation");
		FieldDef defRefTaxObservation = new StringFieldDef("referentiel_taxo_observation");
		FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
		FieldDef defCertitudeObservation = new StringFieldDef("certitude");
		FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
		FieldDef defFamilleObservation = new StringFieldDef("famille_observation");
		FieldDef defAbondanceObservation = new StringFieldDef("abondance");
		FieldDef defPhenologieObservation = new StringFieldDef("phenologie");
		FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
		FieldDef defAltObservation = new StringFieldDef("altitude_observation");
		FieldDef defDateObservation = new StringFieldDef("date_observation");
		FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");
		
		// Non affiches :
		FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");
 
		FieldDef[] defTab = {defEtatObservation, defRefTaxObservation,defNomSaisiObservation, defCertitudeObservation, defNomRetenuObservation, defFamilleObservation, defAbondanceObservation,
				defPhenologieObservation, defLieuObservation, defAltObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation };
		
		return defTab;
	}
	
	
	// GESTION DE LA PAGINATION
	public ListeObservation getCacheListeObservation() {
		return cacheListeObservation;
	}
 
	/**
	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
	 * en cours
	 * @param nbElements le nombre d'élements total
	 * @return le nombre de pages 
	 */
	public int calculerNbPages(int nbElements)
	{
		// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
		// pour eviter qu'il arrondisse mal la division
		// nombre de pages = (nombre d'element / taille de la page) arrondi à l'entier superieur
		double nPage = (1.0*nbElements)/(1.0*taillePage) ; 
		double nPageRound = Math.ceil(nPage) ;
		Double nPageInt = new Double(nPageRound) ;
		
		return nPageInt.intValue() ; 
	}
 
	/**
	 * Recalcule la page en cours lors du changement du nombre d'élements
	 * @param nbElements le nombre d'élements total
	 * @return la nouvelle page encours
	 */
	public int calculerPageCourante(int nbElements)
	{
		// on calcule le nombre de page
		int nouvelNbPages = calculerNbPages(nbElements) ;
		// la nouvelle page en cours
		double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
		
		// on arrondit au supérieur
		double nPageRound = Math.ceil(nPageCourante) ;
		Double nPageInt = new Double(nPageRound) ;
		
		return Math.abs(nPageInt.intValue()) ; 
	}
	
	/**
	 * Appelle le modèle pour lui demander les données d'une page à afficher
	 * @param pageCourante le numéro de page à affciher
	 */
	@Override
	public void changerNumeroPage(int pageCourante) {
		pageEncours = pageCourante ;
		masquerChargement();
		
		enregistrerEtatTri();
		// On lance le chargerment des observations
		observationMediateur.obtenirNombreObservation();
		getToolBarVue().changerPageCourante(pageCourante);	
	}
	
	
	/**
	 * Appelle le modèle pour qu'il change la taille de page utilisée
	 * @param nouvelleTaillePage la nouvelle taille de page
	 */
	@Override
	public void changerTaillePage(int nouvelleTaillePage) {
	
		taillePage = nouvelleTaillePage ;
		pageEncours = calculerPageCourante(nbElements) ;
		
		enregistrerEtatTri();
 
		masquerChargement();
 
		// 	On lance le chargement des observations
		observationMediateur.obtenirNombreObservation();
		
		// et on met à jour la taille de page dans les barres d'outils
		getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);	
	}
 
	
	/**
	 * Met à jour les barre d'outils avec des nouvelles valeurs
	 * @param pageMax le nombre de pages
	 * @param pageEncours la page en cours
	 * @param taillePage la taille de page
	 * @param nbElement le nombre d'élements par page
	 */
	public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement) {			
		int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
		getToolBarVue().rafraichir(pages, false) ;
	}
	
	/**
	 * Renvoie la taille de page en cours d'utilisation
	 * @return la taille de page
	 */
	public int getTaillePage() {
		
		return taillePage;
	}
	
	/**
	 * Renvoie le numéro de la page encours (attention on commence à 0)
	 * @return le numéro de la page en cours
	 */
	public int getPageEncours() {
		
		return pageEncours;
	}
	
	private void enregistrerEtatTri() {
		if(triActif) {
			this.directionTri = st.getSortState().getDirection();
			this.champTri = st.getSortState().getField();
		}
	}
	
	public void afficherFiltres(String[][] filtresEnCours) {
		
		String texteFiltresEnCours = "";
		
		for(int i = 0; i < filtresEnCours.length; i++) {
			if(Util.filtreValide(filtresEnCours[i])) {
				
				if(!texteFiltresEnCours.equals("")) {
					texteFiltresEnCours += " - ";
				}
				
				texteFiltresEnCours += "<span class=\"affichage_filtre\">"+
											transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+
									   " <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_obs_"+filtresEnCours[i][0]+"\" />"+
										"</span>";
			}
		}
		
		if(!texteFiltresEnCours.equals("")) {
			texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>";
		}
		
		this.setTitle("Observations"+texteFiltresEnCours) ;
		
		for(int i = 0; i < filtresEnCours.length; i++) {
			
			if(Util.filtreValide(filtresEnCours[i])) {
				if(Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]) != null) {
					
					Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]).addListener("click", new EventCallback() {
						
						@Override
						public void execute(EventObject e) {
							e.stopEvent();
							observationMediateur.viderFiltre(e.getTarget().getAttribute("rel"));
						}
						
					});
				}
			}
		}
	}
	
	private String transformerNomFiltre(String nomFiltre) {
		
		if(nomFiltre.equals("departement")) {
			nomFiltre = "departement";
		}
		
		if(nomFiltre.equals("commune")) {
			nomFiltre = "commune";
		}
		
		if(nomFiltre.equals("nom_taxon")) {
			nomFiltre = "recherche";
		}
		
		if(nomFiltre.equals("id_mots_cles")) {
			nomFiltre = "projets";
		}
		
		return nomFiltre;
		
	}
	
	private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) {
		
		String valeurFiltreTransformee = valeurFiltre;
		
		if(nomFiltre.equals("id_mots_cles")) {
			
			String[] tabMotsCles = valeurFiltre.split(";");
			String[] tabMotsClesTexte = observationMediateur.obtenirTexteMotsCles(tabMotsCles);
			
			if(tabMotsClesTexte.length > 1) {
				valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte);
			} else {
				valeurFiltreTransformee = tabMotsClesTexte[0];
			}
		}
		
		if(nomFiltre.equals("mois")) {
			valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre));
		}
		
		valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("000null", "inconnue");
		valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("null", "inconnue");
		valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("NULL", "inconnue");
 
		return valeurFiltreTransformee;
		
	}
 
	public void raz() {		
		RecordDef rd = new RecordDef(getDefinitionChamps());
		st = new Store(rd);
		// on associe le store
		this.setStore(st);	
	}
	
	public boolean verifierFormatDate(String date) {
		
		String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ;
		if(date.matches(regex) && !date.equals("0000-00-00")) {
			return true ;
		}
		else {
			return false;
		}
	}
	
	public boolean getTailleInitialisee() {
		return tailleInitialisee ;
	}
	
	public void setTailleInitialisee() {
		tailleInitialisee = true;
	}
 
	public String renvoyerTri() {
		String tri = "ordre";
		if(triActif) {
			HashMap<String, String> corr = Ontologies.getCorrespondanceGrilleObservationChampsTri();
			if(corr.containsKey(champTri)) {
				tri = corr.get(champTri);
			}
		}
		return tri;
	}
 
	public String renvoyerDirectionTri() {
		try {
			return (triActif) ? directionTri.getDirection() : "ASC";
		} catch (Exception e) {
			return "ASC";
		}
	}
}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java @ 3898 – Rev 1705 → 2033

Rev 1705		Rev 2033
1	`package org.tela_botanica.client.vues.observation;`	1	`package org.tela_botanica.client.vues.observation;`
2		2
-		3
3		4	`import java.util.HashMap;`
4	`import java.util.Iterator;`	5	`import java.util.Iterator;`
5		6
6	`import org.tela_botanica.client.modeles.objets.ListeObservation;`	7	`import org.tela_botanica.client.modeles.objets.ListeObservation;`
7	`import org.tela_botanica.client.modeles.objets.Observation;`	8	`import org.tela_botanica.client.modeles.objets.Observation;`
8	`import org.tela_botanica.client.modeles.objets.Ontologies;`	9	`import org.tela_botanica.client.modeles.objets.Ontologies;`
9	`import org.tela_botanica.client.observation.ObservationMediateur;`	10	`import org.tela_botanica.client.observation.ObservationMediateur;`
10	`import org.tela_botanica.client.util.Util;`	11	`import org.tela_botanica.client.util.Util;`
11	`import org.tela_botanica.client.vues.BarrePaginationVue;`	12	`import org.tela_botanica.client.vues.BarrePaginationVue;`
12	`import org.tela_botanica.client.interfaces.ListePaginable;`	13	`import org.tela_botanica.client.interfaces.ListePaginable;`
13	`import org.tela_botanica.client.interfaces.Rafraichissable;`	14	`import org.tela_botanica.client.interfaces.Rafraichissable;`
14	`import org.tela_botanica.client.interfaces.VueListable;`	15	`import org.tela_botanica.client.interfaces.VueListable;`
-		16
-		17	`import com.google.gwt.user.client.Event;`
15		18	`import com.google.gwt.user.client.Timer;`
16	`import com.google.gwt.user.client.Window;`	19	`import com.google.gwt.user.client.Window;`
17	`import com.gwtext.client.core.EventCallback;`	20	`import com.gwtext.client.core.EventCallback;`
18	`import com.gwtext.client.core.EventObject;`	21	`import com.gwtext.client.core.EventObject;`
19	`import com.gwtext.client.core.Ext;`	22	`import com.gwtext.client.core.Ext;`
20	`import com.gwtext.client.core.ExtElement;`	23	`import com.gwtext.client.core.ExtElement;`
21	`import com.gwtext.client.core.SortDir;`	24	`import com.gwtext.client.core.SortDir;`
22	`import com.gwtext.client.data.ArrayReader;`	25	`import com.gwtext.client.data.ArrayReader;`
23	`import com.gwtext.client.data.FieldDef;`	26	`import com.gwtext.client.data.FieldDef;`
24	`import com.gwtext.client.data.IntegerFieldDef;`	27	`import com.gwtext.client.data.IntegerFieldDef;`
25	`import com.gwtext.client.data.MemoryProxy;`	28	`import com.gwtext.client.data.MemoryProxy;`
26	`import com.gwtext.client.data.Record;`	29	`import com.gwtext.client.data.Record;`
27	`import com.gwtext.client.data.RecordDef;`	30	`import com.gwtext.client.data.RecordDef;`
28	`import com.gwtext.client.data.SortState;`	31	`import com.gwtext.client.data.SortState;`
29	`import com.gwtext.client.data.Store;`	32	`import com.gwtext.client.data.Store;`
30	`import com.gwtext.client.data.StringFieldDef;`	33	`import com.gwtext.client.data.StringFieldDef;`
31	`import com.gwtext.client.dd.DragData;`	34	`import com.gwtext.client.dd.DragData;`
32	`import com.gwtext.client.dd.DragDropConfig;`	35	`import com.gwtext.client.dd.DragDropConfig;`
33	`import com.gwtext.client.dd.DragSource;`	36	`import com.gwtext.client.dd.DragSource;`
34	`import com.gwtext.client.dd.DropTarget;`	37	`import com.gwtext.client.dd.DropTarget;`
35	`import com.gwtext.client.dd.DropTargetConfig;`	38	`import com.gwtext.client.dd.DropTargetConfig;`
36	`import com.gwtext.client.widgets.Button;`	39	`import com.gwtext.client.widgets.Button;`
37	`import com.gwtext.client.widgets.Component;`	40	`import com.gwtext.client.widgets.Component;`