Rev 1488 | Rev 1542 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed
package org.tela_botanica.client.vues.observation;
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.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.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.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.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;
/**
* Config de colonne
*/
private ColumnConfig nomSaisiObservation;
/**
* Config de colonne
*/
private ColumnConfig nomRetenuObservation;
/**
* Config de colonne
*/
private ColumnConfig lieuObservation;
/**
* Config de colonne
*/
private ColumnConfig dateObservation;
/**
* Config de colonne
*/
private ColumnConfig ordreObservation;
/**
* Config de colonne
*/
private ColumnConfig abondanceObservation;
/**
* Config de colonne
*/
private ColumnConfig certitudeObservation;
/**
* Modele de colonnes
*/
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 ;
/**
* 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>");
barreActions.addButton(publier);
barreActions.addButton(privatiser);
barreActions.addSpacer();
barreActions.addButton(supprimer);
barreActions.addSpacer();
barreActions.addButton(importer);
barreActions.addSpacer();
barreActions.addItem(exporter);
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) {
if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {
return "" ;
}
else
{
}
return value.toString() ;
}
} ;
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 "" ;
}
}
});
nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200, true, colRend);
nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200, true, colRend);
lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200, 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"));
}
});
ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50, true, colRend);
ColumnConfig[] cm = {etatObservation, nomSaisiObservation, certitudeObservation, nomRetenuObservation, abondanceObservation, lieuObservation, dateObservation, ordreObservation};
return cm;
}
/**
* Ajoute les listeners pour la gestion des évènements
*/
private void ajouterListeners() {
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();
}
});
}
});
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()][9];
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.getNomSaisi();
observationData[i][2] = obs.getCertitude();
observationData[i][3] = obs.getNomRetenu();
observationData[i][4] = obs.getAbondance();
observationData[i][5] = Util.formaterLieu(obs, modeleLieu);
observationData[i][6] = obs.getDate();
observationData[i][7] = obs.getNumeroOrdre();
observationData[i][8] = 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]) ;
masquerChargement();
observationMediateur.obtenirListeObservation(this);
}
// si l'on a reçu une Observation
if(nouvelleDonnees instanceof Observation) {
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)
{
observationMediateur.obtenirNombreObservation() ;
}
if(!getTailleInitialisee()) {
if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) {
doLayout();
setTailleInitialisee();
}
}
}
private FieldDef[] getDefinitionChamps() {
// creation du store qui les contient
FieldDef defEtatObservation = new StringFieldDef("etat_observation");
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
FieldDef defCertitudeObservation = new StringFieldDef("certitude");
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
FieldDef defAbondanceObservation = new StringFieldDef("abondance");
FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
FieldDef defDateObservation = new StringFieldDef("date_observation");
FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");
// Non affiches :
FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defCertitudeObservation, defNomRetenuObservation, defAbondanceObservation,
defLieuObservation, 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();
// 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) ;
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;
}
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;
}
}