Rev 1337 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed
package org.tela_botanica.client.vues.publication;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.tela_botanica.client.ComposantClass;
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampComboBoxRechercheTempsReelPaginable;
import org.tela_botanica.client.composants.InfoLogger;
import org.tela_botanica.client.composants.pagination.ProxyPersonnes;
import org.tela_botanica.client.composants.pagination.ProxyProjets;
import org.tela_botanica.client.composants.pagination.ProxyStructures;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.MenuApplicationId;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.modeles.personne.Personne;
import org.tela_botanica.client.modeles.personne.PersonneListe;
import org.tela_botanica.client.modeles.projet.Projet;
import org.tela_botanica.client.modeles.projet.ProjetListe;
import org.tela_botanica.client.modeles.publication.Publication;
import org.tela_botanica.client.modeles.publication.PublicationAPersonne;
import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe;
import org.tela_botanica.client.modeles.structure.Structure;
import org.tela_botanica.client.modeles.structure.StructureListe;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.Pattern;
import org.tela_botanica.client.util.UtilArray;
import org.tela_botanica.client.util.UtilString;
import org.tela_botanica.client.vues.FenetreForm;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireBarreValidation;
import org.tela_botanica.client.vues.personne.PersonneForm;
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.Style.SortDir;
import com.extjs.gxt.ui.client.core.XTemplate;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.ModelType;
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.Store;
import com.extjs.gxt.ui.client.store.StoreEvent;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.HorizontalPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.button.ButtonBar;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.Field;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.Validator;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnData;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.GridCellRenderer;
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
import com.extjs.gxt.ui.client.widget.grid.RowExpander;
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.FlowLayout;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
import com.extjs.gxt.ui.client.widget.layout.RowData;
import com.extjs.gxt.ui.client.widget.layout.RowLayout;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Window;
public class PublicationForm extends Formulaire implements Rafraichissable {
private Publication publication;
private PersonneListe auteursInitialListe = null;
private static boolean publicationAPersonneListeChargementOk = false;
private PersonneListe auteursAjoutes = null;
private PersonneListe auteursSupprimes = null;
private ContentPanel auteursFieldset = null;
private ChampComboBoxRechercheTempsReelPaginable projetsCombo = null;
private ArrayList<ComboBox<Personne>> auteurComboboxListe = null;
private ListStore<Personne> auteursStorePartage = null;
private static boolean auteurStorePartageChargementOk = false;
private FieldSet generalitesFieldset = null;
private TextField<String> titreChp = null;
private TextField<String> collectionChp = null;
private TextField<String> uriChp = null;
private FieldSet editionFieldset = null;
private ChampComboBoxRechercheTempsReelPaginable editeurCombobox = null;
private static boolean editeursOk = false;
private TextField<String> datePublicationChp = null;
private TextField<String> tomeChp = null;
private TextField<String> fasciculeChp = null;
private TextField<String> pagesChp = null;
boolean auteursAffiches = false;
private static boolean formulaireValideOk = false;
private static boolean publicationValideOk = false;
private static boolean auteursValideOk = false;
private static boolean publicationOk = false;
private static boolean attenteAjoutAuteursOk = true;
private static boolean attenteSuppressionAuteursOk = true;
private LayoutContainer zoneHaut, zoneBas;
private static int idGenere = 1;
private ToolBar barreOutils = null;
private EditorGrid<Personne> grille;
private PersonneListe personnesAjoutees = null;
private PersonneListe personnesSupprimees = null;
private ChampComboBoxRechercheTempsReelPaginable personnesSaisiesComboBox = null;
private ChampComboBoxRechercheTempsReelPaginable recherchePersonnesCombo = null;
private Button personnesBoutonSupprimer = null;
private Button personnesBoutonModifier = null;
private ComboBox<Valeur> typeRelationCombo = null;
private List<Valeur> roles = null;
private PersonneListe listePersonne = new PersonneListe();
private FenetreForm fenetreFormulaire = null;
public PublicationForm(Mediateur mediateurCourrant, String publicationId) {
initialiserPublicationForm(mediateurCourrant, publicationId);
}
public PublicationForm(Mediateur mediateurCourrant, String publicationId, Rafraichissable vueARafraichirApresValidation) {
vueExterneARafraichirApresValidation = vueARafraichirApresValidation;
initialiserPublicationForm(mediateurCourrant, publicationId);
}
private void initialiserPublicationForm(Mediateur mediateurCourrant, String publicationId) {
auteursInitialListe = new PersonneListe();
initialiserValidation();
initialiserAffichageAuteurs();
publication = new Publication();
publication.setId(publicationId);
String modeDeCreation = (UtilString.isEmpty(publication.getId()) ? Formulaire.MODE_AJOUTER : Formulaire.MODE_MODIFIER);
initialiserFormulaire(mediateurCourrant, modeDeCreation, MenuApplicationId.PUBLICATION);
panneauFormulaire.setLayout(new RowLayout());
panneauFormulaire.setStyleAttribute("padding", "0");
zoneHaut = new LayoutContainer(new FitLayout());
zoneBas = new LayoutContainer(new FlowLayout());
panneauFormulaire.add(zoneHaut, new RowData(1, 0.3));
panneauFormulaire.add(zoneBas, new RowData(1, 0.5));
panneauFormulaire.setScrollMode(Scroll.AUTO);
genererTitreFormulaire();
creerZoneAuteurs();
zoneHaut.add(auteursFieldset);
creerZoneGeneralites();
zoneBas.add(generalitesFieldset);
creerZoneEdition();
zoneBas.add(editionFieldset);
if (modeDeCreation.equals(Formulaire.MODE_MODIFIER)) {
mediateurCourrant.selectionnerPublication(this, publicationId);
mediateurCourrant.selectionnerPublicationAPersonne(this, publicationId, null, PublicationAPersonne.ROLE_AUTEUR);
}
}
public void actualiserEtatBoutonsBarreOutils() {
// Activation des boutons si la grille contient un élément
if (grille.getStore().getCount() > 0) {
personnesBoutonSupprimer.enable();
personnesBoutonModifier.enable();
}
// Désactivation des boutons si la grille ne contient plus d'élément
if (grille.getStore().getCount() == 0) {
personnesBoutonSupprimer.disable();
personnesBoutonModifier.disable();
}
}
private ToolBar creerBarreOutilsGrille() {
ToolBar barreOutils = new ToolBar();
Button ajouterBouton = creerBoutonAjouter();
barreOutils.add(ajouterBouton);
barreOutils.add(new Text(" ou "));
creerComboBoxPersonnesSaisies();
barreOutils.add(personnesSaisiesComboBox);
barreOutils.add(new SeparatorToolItem());
personnesBoutonModifier = creerBoutonModifier();
barreOutils.add(personnesBoutonModifier);
barreOutils.add(new SeparatorToolItem());
personnesBoutonSupprimer = creerBoutonSupprimer();
barreOutils.add(personnesBoutonSupprimer);
barreOutils.add(new SeparatorToolItem());
Button rafraichirBouton = creerBoutonRafraichir();
barreOutils.add(rafraichirBouton);
return barreOutils;
}
private Button creerBoutonAjouter() {
Button bouton = new Button(i18nC.ajouter());
bouton.setIcon(Images.ICONES.vcardAjouter());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_AJOUTER);
fenetreFormulaire.show();
}
});
return bouton;
}
private Button creerBoutonModifier() {
Button bouton = new Button(i18nC.modifier());
bouton.setIcon(Images.ICONES.vcardModifier());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
if (personneSaisieSelectionnee == null) {
InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
} else {
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_MODIFIER);
fenetreFormulaire.show();
}
}
});
return bouton;
}
private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
String personneId = null;
if (mode.equals(Formulaire.MODE_MODIFIER)) {
Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
personneId = personneSaisieSelectionnee.getId();
}
final FenetreForm fenetre = new FenetreForm("");
final PersonneForm formulaire = creerFormulairePersonne(fenetre, personneId);
fenetre.add(formulaire);
return fenetre;
}
private PersonneForm creerFormulairePersonne(final FenetreForm fenetre, final String personneId) {
PersonneForm formulairePersonne = new PersonneForm(mediateur, personneId, this);
FormPanel panneauFormulaire = formulairePersonne.getFormulaire();
fenetre.setHeading(panneauFormulaire.getHeading());
panneauFormulaire.setHeaderVisible(false);
panneauFormulaire.setTopComponent(null);
// FIXME : avec GXT-2.1.0 la redéfinition du bottom component ne marche plus. Nous le cachons et en créeons un dans la fenêtre.
panneauFormulaire.getBottomComponent().hide();
SelectionListener<ButtonEvent> ecouteur = creerEcouteurValidationFormulairePersonne(fenetre, formulairePersonne);
final ButtonBar barreValidation = new FormulaireBarreValidation(ecouteur);
fenetre.setBottomComponent(barreValidation);
return formulairePersonne;
}
private SelectionListener<ButtonEvent> creerEcouteurValidationFormulairePersonne(final FenetreForm fenetre, final PersonneForm formulaire) {
SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
String code = ((Button) ce.getComponent()).getData("code");
if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
if (formulaire.soumettreFormulaire()) {
fenetre.hide();
}
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
formulaire.soumettreFormulaire();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
fenetre.hide();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
fenetreFormulaire.hide();
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(formulaire.mode);
fenetreFormulaire.show();
}
}
};
return ecouteur;
}
private Button creerBoutonSupprimer() {
Button bouton = new Button(i18nC.supprimer());
bouton.setIcon(Images.ICONES.vcardSupprimer());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
if (personneSaisieSelectionnee == null) {
InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
} else {
supprimerDansGrille(personneSaisieSelectionnee);
}
}
});
return bouton;
}
private Button creerBoutonRafraichir() {
Button bouton = new Button(i18nC.rafraichir());
bouton.setIcon(Images.ICONES.rafraichir());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
actualiserGrille();
}
});
return bouton;
}
private void actualiserGrille() {
if (mode.equals(Formulaire.MODE_MODIFIER)) {
// FIXME : c'est la merde
//mediateur.selectionner(this, null, personneSelectionnee.getId(), "%");
} else {
grille.getStore().removeAll();
layout();
}
}
private void creerComboBoxPersonnesSaisies() {
ModelType modelTypePersonnes = new ModelType();
modelTypePersonnes.setRoot("personnes");
modelTypePersonnes.setTotalName("nbElements");
modelTypePersonnes.addField("cp_fmt_nom_complet");
modelTypePersonnes.addField("cp_id_personne");
modelTypePersonnes.addField("cp_code_postal");
modelTypePersonnes.addField("cp_ville");
modelTypePersonnes.addField("cp_truk_courriel");
String displayNamePersonnes = "cp_fmt_nom_complet";
ProxyPersonnes<ModelData> proxyPersonnes = new ProxyPersonnes<ModelData>();
personnesSaisiesComboBox = new ChampComboBoxRechercheTempsReelPaginable(proxyPersonnes, modelTypePersonnes, displayNamePersonnes);
personnesSaisiesComboBox.getCombo().addListener(Events.Select, new Listener<BaseEvent>() {
public void handleEvent(BaseEvent be) {
if (personnesSaisiesComboBox.getValeur() instanceof ModelData) {
// N'ajouter l'auteur que s'il n'est pas déjà présent dans la grille et dans les valeurs initiales
Personne personneSaisieSelectionnee = new Personne(personnesSaisiesComboBox.getValeur());
if (grille.getStore().findModel(personneSaisieSelectionnee) != null) {
Info.display("Information", "La personne est déjà présente dans la liste d'auteurs");
} else {
if (!auteursInitialListe.containsValue(personneSaisieSelectionnee)) {
auteursAjoutes.put(personneSaisieSelectionnee.getId(), personneSaisieSelectionnee);
}
ajouterDansGrille(personneSaisieSelectionnee);
personnesSaisiesComboBox.getCombo().setValue(null);
}
}
}
});
}
private void ajouterDansGrille(Personne personne) {
ajouterDansGrille(personne, 0);
}
private void ajouterDansGrille(Personne personne, int index) {
if (personne != null) {
if (!grille.getStore().contains(personne)) {
//1) si elle ne fait pas partie des initiaux, ajouter à la liste à ajouter
if (!auteursInitialListe.containsValue(personne)) {
auteursAjoutes.put(personne.getId(), personne);
}
// L'enlever de la liste à supprimer
if (auteursSupprimes.containsValue(personne)) {
auteursSupprimes.remove(personne);
}
//2) Ajouter a la grille
grille.getStore().insert(personne, index);
grille.getSelectionModel().select(index, false);
} else {
InfoLogger.display("Information", "La personne choisie existe déjà dans la liste.");
}
}
}
/**
* Met à jour la grille avec les informations contenus dans la variable listePublicationsLiees
*/
private void mettreAJourGrille() {
grille.getStore().removeAll();
grille.getStore().add(listePersonne.toList());
}
private void supprimerDansGrille(Personne personne) {
if (personne != null) {
//1) Ajouter a la liste des personne à supprimer uniquement si est présente dans la liste initiale
if (auteursInitialListe.containsValue(personne)) {
auteursSupprimes.put(personne.getId(), personne);
}
if (auteursAjoutes.containsValue(personne)) {
auteursAjoutes.remove(personne);
}
//2) Supprimer la personne de la liste
grille.getStore().remove(personne);
} else {
Info.display("Information", "Vous devez sélectionner une personne");
}
}
private EditorGrid<Personne> creerGrille() {
ListStore<Personne> storeGrille = new ListStore<Personne>();
storeGrille.addListener(Store.Add, new Listener<StoreEvent<Personne>>() {
public void handleEvent(StoreEvent<Personne> ce) {
actualiserEtatBoutonsBarreOutils();
}
});
storeGrille.addListener(Store.Remove, new Listener<StoreEvent<Personne>>() {
public void handleEvent(StoreEvent<Personne> ce) {
actualiserEtatBoutonsBarreOutils();
}
});
storeGrille.addListener(Store.Update, new Listener<StoreEvent<Personne>>() {
public void handleEvent(StoreEvent<Personne> ce) {
if (ce.getRecord().isModified("_role_") && !ce.getModel().get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
ce.getModel().set("_etat_", aDonnee.ETAT_MODIFIE);
}
}
});
List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
colonnes.add(new ColumnConfig("fmt_nom_complet", i18nC.personneNomComplet(), 150));
colonnes.add(new ColumnConfig("code_postal", i18nC.personneCodePostal(), 150));
colonnes.add(new ColumnConfig("ville", i18nC.personneVille(), 75));
colonnes.add(new ColumnConfig("truk_courriel", i18nC.personneCourriel(), 75));
GridSelectionModel<Personne> modeleDeSelection = new GridSelectionModel<Personne>();
ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
EditorGrid<Personne> grillePublications = new EditorGrid<Personne>(storeGrille, modeleDeColonnes);
grillePublications.setHeight("100%");
grillePublications.setBorders(true);
grillePublications.setSelectionModel(modeleDeSelection);
grillePublications.getView().setForceFit(true);
grillePublications.setAutoExpandColumn("fmt_nom_complet");
grillePublications.setStripeRows(true);
grillePublications.setTrackMouseOver(true);
return grillePublications;
}
private void genererTitreFormulaire() {
String titre = i18nC.publicationTitreFormAjout();
if (mode.equals(Formulaire.MODE_MODIFIER)) {
titre = i18nC.publicationTitreFormModif();
if (publication != null) {
titre += " - "+i18nC.id()+": "+publication.getId()+" - "+publication.getObjetDeLaPublication();
}
}
panneauFormulaire.setHeading(titre);
}
private void creerZoneAuteurs() {
auteursFieldset = new ContentPanel();
auteursFieldset.setLayout(new FitLayout());
auteursFieldset.setHeading("Auteurs");
auteurComboboxListe = new ArrayList<ComboBox<Personne>>(0);
mediateur.clicObtenirListeAuteurs(this);
creerChampsAuteur();
}
private void creerChampsAuteur() {
auteursFieldset.removeAll();
barreOutils = creerBarreOutilsGrille();
auteursFieldset.setTopComponent(barreOutils);
grille = creerGrille();
auteursFieldset.add(grille);
auteursFieldset.layout();
}
public void creerChampAuteurEtBoutonSupprimer(Personne auteur) {
/*final HorizontalPanel panneauHorizontal = new HorizontalPanel();
LayoutContainer panneauChampTxt = new LayoutContainer();
panneauChampTxt.setLayout(new FormLayout());
final ComboBox<Personne> auteursSaisisComboBox = creerComboBoxAuteursSaisis();
if (auteur != null) {
auteursSaisisComboBox.setValue(auteur);
auteursSaisisComboBox.validate();
}
auteurComboboxListe.add(auteursSaisisComboBox);
auteursSaisisComboBox.setFieldLabel(i18nC.publicationAuteurSingulier()+" "+auteurComboboxListe.size());
panneauChampTxt.add(auteursSaisisComboBox, new FormData(300, 0));
panneauHorizontal.add(panneauChampTxt);
Button supprimerAuteurBouton = new Button();
supprimerAuteurBouton.setIcon(Images.ICONES.supprimer());
supprimerAuteurBouton.setToolTip(i18nC.supprimer());
supprimerAuteurBouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent be) {
auteurComboboxListe.remove(auteursSaisisComboBox);
conteneurChamps.remove(panneauHorizontal);
int numeroAuteurs = 1;
for (Iterator<ComboBox<Personne>> it = auteurComboboxListe.iterator(); it.hasNext();) {
it.next().setFieldLabel(i18nC.publicationAuteurSingulier()+" "+numeroAuteurs);
numeroAuteurs++;
}
auteursFieldset.layout();
}
});
panneauHorizontal.add(supprimerAuteurBouton);
conteneurChamps.add(panneauHorizontal);
auteursFieldset.layout();*/
}
/*
private ComboBox<Personne> creerComboBoxAuteursSaisis() {
ListStore<Personne> auteursStore = new ListStore<Personne>();
auteursStore.add(auteursStorePartage.getModels());
ComboBox<Personne> comboBox = new ComboBox<Personne>();
comboBox.setEmptyText(i18nC.chercherPersonneSaisi());
comboBox.setEditable(true);
comboBox.setAllowBlank(false);
comboBox.setForceSelection(true);
comboBox.setDisplayField("fmt_nom_complet");
comboBox.setTriggerAction(TriggerAction.ALL);
comboBox.setStore(auteursStore);
comboBox.setMessageTarget("tooltip");
comboBox.addStyleName(ComposantClass.OBLIGATOIRE);
comboBox.addListener(Events.Valid, creerEcouteurChampObligatoire());
return comboBox;
}*/
private void creerZoneGeneralites() {
FormLayout layout = new FormLayout();
layout.setLabelWidth(200);
// Fieldset Infos Générales
generalitesFieldset = new FieldSet();
generalitesFieldset.setHeading("Informations générales");
generalitesFieldset.setCollapsible(true);
generalitesFieldset.setLayout(layout);
ModelType modelTypeProjets = new ModelType();
modelTypeProjets.setRoot("projets");
modelTypeProjets.setTotalName("nbElements");
modelTypeProjets.addField("cpr_nom");
modelTypeProjets.addField("cpr_id_projet");
String displayNameProjets = "cpr_nom";
ProxyProjets<ModelData> proxyProjets = new ProxyProjets<ModelData>();
projetsCombo = new ChampComboBoxRechercheTempsReelPaginable(proxyProjets, modelTypeProjets, displayNameProjets);
projetsCombo.setWidth(200, 600);
projetsCombo.getCombo().setTabIndex(tabIndex++);
projetsCombo.getCombo().setFieldLabel(i18nC.projetChamp());
projetsCombo.getCombo().setForceSelection(true);
projetsCombo.getCombo().addStyleName(ComposantClass.OBLIGATOIRE);
projetsCombo.getCombo().addListener(Events.Valid, Formulaire.creerEcouteurChampObligatoire());
projetsCombo.getCombo().setValidator(new Validator() {
public String validate(Field<?> field, String value) {
String retour = null;
if (field.getRawValue().equals("")) {
field.setValue(null);
} else if (projetsCombo.getStore().findModel("cpr_nom", field.getRawValue()) == null) {
String contenuBrut = field.getRawValue();
field.setValue(null);
field.setRawValue(contenuBrut);
retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
}
return retour;
}
});
generalitesFieldset.add(projetsCombo, new FormData(600, 0));
titreChp = new TextField<String>();
titreChp.setName("cpu");
titreChp.setFieldLabel("Titre de l'article ou de l'ouvrage");
titreChp.addStyleName(ComposantClass.OBLIGATOIRE);
titreChp.addListener(Events.Valid, creerEcouteurChampObligatoire());
generalitesFieldset.add(titreChp, new FormData(450, 0));
collectionChp = new TextField<String>();
collectionChp.setFieldLabel("Intitulé de la revue ou de la collection");
generalitesFieldset.add(collectionChp, new FormData(450, 0));
uriChp = new TextField<String>();
uriChp.setFieldLabel("URL de la publication");
generalitesFieldset.add(uriChp, new FormData(450, 0));
}
private void creerZoneEdition() {
FormLayout layout = new FormLayout();
layout.setLabelWidth(200);
// Fieldset Edition
editionFieldset = new FieldSet();
editionFieldset.setHeading("Édition");
editionFieldset.setCollapsible(true);
editionFieldset.setLayout(layout);
/*****************************************************/
/** Champ 'Editeur de la publication' **/
/*****************************************************/
ModelType modelTypeStructures = new ModelType();
modelTypeStructures.setRoot("structures");
modelTypeStructures.setTotalName("nbElements");
modelTypeStructures.addField("cs_nom");
modelTypeStructures.addField("cs_id_structure");
String displayNameStructures = "cs_nom";
ProxyStructures<ModelData> proxyStructures = new ProxyStructures<ModelData>();
editeurCombobox = new ChampComboBoxRechercheTempsReelPaginable(proxyStructures, modelTypeStructures, displayNameStructures);
editeurCombobox.setWidth(200, 600);
editeurCombobox.getCombo().setTabIndex(tabIndex++);
editeurCombobox.getCombo().setEmptyText("Sélectionner un éditeur...");
editeurCombobox.getCombo().setFieldLabel("Éditeur de la publication");
editeurCombobox.getCombo().setEditable(true);
editionFieldset.add(editeurCombobox, new FormData(600, 0));
/*********************************************/
/** Champ 'Date de publication' **/
/*********************************************/
datePublicationChp = new TextField<String>();
datePublicationChp.setMaxLength(4);
datePublicationChp.setMinLength(4);
datePublicationChp.setFieldLabel("Année de publication");
datePublicationChp.addStyleName(ComposantClass.OBLIGATOIRE);
datePublicationChp.addListener(Events.Valid, creerEcouteurChampObligatoire());
editionFieldset.add(datePublicationChp, new FormData(40, 0));
/*****************************/
/** Champ '' **/
/*****************************/
tomeChp = new TextField<String>();
tomeChp.setFieldLabel("Série de la revue ou tome");
editionFieldset.add(tomeChp, new FormData(75, 0));
/*****************************/
/** Champ '' **/
/*****************************/
fasciculeChp = new TextField<String>();
fasciculeChp.setFieldLabel("Fascicule de la revue");
editionFieldset.add(fasciculeChp, new FormData(75, 0));
/*****************************/
/** Champ '' **/
/*****************************/
pagesChp = new TextField<String>();
pagesChp.setFieldLabel("Pages");
pagesChp.setToolTip("Fomat : NBRE ou NBRE-NBRE. ('NBRE' correspond à une suite de chiffres arabes ou romains ou à un point d'interrogation '?' dans le cas d'une donnée inconnue)");
editionFieldset.add(pagesChp, new FormData(100, 0));
}
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof Publication) {
// Si on a reçu les details d'une publication
rafraichirPublication((Publication) nouvellesDonnees);
} else if (nouvellesDonnees instanceof PublicationAPersonneListe) {
rafraichirListeAuteurs((PublicationAPersonneListe) nouvellesDonnees);
} else if (nouvellesDonnees instanceof Information) {
rafraichirInformation((Information) nouvellesDonnees);
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
synchronisation();
}
private void synchronisation() {
// Respecter l'ordre et faire attention à la réinitialisation des jetons
// 1. gestion des auteurs (Modif ou Ajout)
// 2. peupler le formulaire (Modif)
// 3. initialisation de la gestion des auteurs ajoutés/supprimés (Modif)
// 4. valider le formulaire (Modif ou Ajout)
if (etrePretAAfficherAuteurs()) {
afficherAuteurs();
initialiserAffichageAuteurs();
}
if (etrePretAPeupler()) {
peuplerFormulaire();
genererTitreFormulaire();
initialiserPeupler();
}
if (avoirAuteursMiseAJourCorrectement()) {
miseAJourAuteursInitialListe();
initialiserAuteurs();
auteursValideOk = true;
}
if (etreValide()) {
initialiserValidation();
repandreRafraichissement();
controlerFermeture();
}
}
private void miseAJourAuteursInitialListe() {
Iterator<String> clesAjoutees = auteursAjoutes.keySet().iterator();
while (clesAjoutees.hasNext()) {
Personne auteurAjoute = auteursAjoutes.get(clesAjoutees.next());
auteursInitialListe.put(auteurAjoute.getId(), auteurAjoute);
}
Iterator<String> clesSupprimees = auteursSupprimes.keySet().iterator();
while (clesSupprimees.hasNext()) {
Personne auteurSupprime = auteursSupprimes.get(clesSupprimees.next());
auteursInitialListe.remove(auteurSupprime.getId());
}
}
private void rafraichirPublication(Publication publi) {
publicationOk = true;
publication = publi;
}
private void rafraichirListeAuteurs(PublicationAPersonneListe auteurs) {
Iterator<String> it = auteurs.keySet().iterator();
while (it.hasNext()) {
Personne auteur = auteurs.get(it.next()).getPersonne();
auteursInitialListe.put(auteur.getId(), auteur);
}
grille.getStore().removeAll();
grille.getStore().add(auteursInitialListe.toList());
publicationAPersonneListeChargementOk = true;
}
private void rafraichirInformation(Information info) {
String type = info.getType();
if (type.equals("ajout_publication") || type.equals("modif_publication")) {
// On vient de soumettre le formulaire, on doit passer à l'étape suivante:
// Validation des auteurs ou fermeture du formulaire
publicationValideOk = true;
if (mode.equals(Formulaire.MODE_AJOUTER)) {
if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String) {
String publicationId = (String) info.getDonnee(0);
if (publicationId.matches("[0-9]+")) {
publication.setId(publicationId);
}
}
attenteAjoutAuteursOk = true;
}
soumettreAuteurs();
}
if (info.getType().equals("liste_personne")) {
PersonneListe listePersonneAuteur = (PersonneListe) info.getDonnee(0);
/*List<Personne> liste = listePersonneAuteur.toList();
auteursStorePartage.removeAll();
auteursStorePartage.add(liste);
auteurStorePartageChargementOk = true;*/
ListStore store = personnesSaisiesComboBox.getStore();
store.removeAll();
store.add(listePersonneAuteur.toList());
} else if (info.getType().equals("ajout_publication_a_personne")) {
attenteAjoutAuteursOk = false;
} else if (info.getType().equals("suppression_publication_a_personne")) {
attenteSuppressionAuteursOk = false;
} else if (info.getType().equals("modif_publication")) {
InfoLogger.display("Modification d'une publication", info.toString());
} else if (info.getType().equals("ajout_publication")) {
if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String && ((String) info.getDonnee(0)).matches("[0-9]+")) {
String publicationId = (String) info.getDonnee(0);
InfoLogger.display("Ajout d'une publication", "La publication '"+publicationId+"' a bien été ajoutée");
} else {
InfoLogger.display("Ajout d'une publication", info.toString());
}
}
}
private boolean avoirAuteursMiseAJourCorrectement() {
boolean ok = false;
if (attenteAjoutAuteursOk == false && attenteSuppressionAuteursOk == false) {
ok = true;
}
return ok;
}
private void afficherAuteurs() {
if (mode.equals(Formulaire.MODE_AJOUTER)) {
creerChampAuteurEtBoutonSupprimer(null);
} else if (mode.equals(Formulaire.MODE_MODIFIER)) {
Iterator<String> itap = auteursInitialListe.keySet().iterator();
while (itap.hasNext()) {
creerChampAuteurEtBoutonSupprimer(auteursInitialListe.get(itap.next()));
}
}
auteursAffiches = true;
}
private void initialiserAffichageAuteurs() {
auteurStorePartageChargementOk = false;
publicationAPersonneListeChargementOk = false;
}
private void initialiserPeupler() {
publicationOk = false;
editeursOk = false;
auteursAffiches = false;
}
private boolean etrePretAAfficherAuteurs() {
boolean ok = false;
if (auteurStorePartageChargementOk
&& ((mode.equals(Formulaire.MODE_MODIFIER) && publicationOk && publicationAPersonneListeChargementOk)
|| (mode.equals(Formulaire.MODE_AJOUTER)))) {
ok = true;
}
return ok;
}
private boolean etrePretAPeupler() {
boolean ok = false;
if (mode.equals(Formulaire.MODE_MODIFIER) && publicationOk && editeursOk) {
ok = true;
}
return ok;
}
private Boolean etreValide() {
Boolean valide = false;
if (formulaireValideOk && auteursValideOk) {
valide = true;
}
return valide;
}
private void initialiserValidation() {
formulaireValideOk = false;
publicationValideOk = false;
initialiserAuteurs();
auteursValideOk = false;
}
private void initialiserAuteurs() {
attenteAjoutAuteursOk = true;
auteursAjoutes = new PersonneListe();
attenteSuppressionAuteursOk = true;
auteursSupprimes = new PersonneListe();
}
private void repandreRafraichissement() {
if (vueExterneARafraichirApresValidation != null) {
String type = "publication_modifiee";
if (mode.equals(Formulaire.MODE_AJOUTER)) {
type = "publication_ajoutee";
}
Information info = new Information(type);
info.setDonnee(0, publication);
vueExterneARafraichirApresValidation.rafraichir(info);
}
}
public boolean soumettreFormulaire() {
formulaireValideOk = verifierFormulaire();
if (formulaireValideOk) {
soumettrePublication();
//Les auteurs seront mis à jour lors du rafraichissement
}
return formulaireValideOk;
}
private void soumettrePublication() {
Publication publicationCollectee = collecterPublication();
if (publicationCollectee != null) {
if (mode.equals(Formulaire.MODE_AJOUTER)) {
mediateur.ajouterPublication(this, publicationCollectee);
} else if (mode.equals(Formulaire.MODE_MODIFIER)) {
mediateur.modifierPublication(this, publicationCollectee);
}
}
}
private void soumettreAuteurs() {
attenteAjoutAuteursOk = false;
attenteSuppressionAuteursOk = false;
//1) Auteurs ajoutés :
// - Créer une PublicationAAuteurListe
PublicationAPersonneListe listeDesAuteurs = new PublicationAPersonneListe();
Iterator<String> itAuteur = auteursAjoutes.keySet().iterator();
while (itAuteur.hasNext()) {
PublicationAPersonne publiAPersonne = new PublicationAPersonne();
String cle = itAuteur.next();
publiAPersonne.setIdPersonne(cle);
publiAPersonne.setIdPublication(publication.getId());
listeDesAuteurs.put(cle, publiAPersonne);
}
// - envoyer au mediateur SSI personnes à ajouter
if (listeDesAuteurs.size() > 0) {
mediateur.ajouterPublicationAPersonne(this, publication.getId(), listeDesAuteurs, PublicationAPersonne.ROLE_AUTEUR);
attenteAjoutAuteursOk = true;
}
//2) Auteurs supprimés :
// - Créer une PublicationAPersonneListe
listeDesAuteurs = new PublicationAPersonneListe();
itAuteur = auteursSupprimes.keySet().iterator();
while (itAuteur.hasNext()) {
PublicationAPersonne publiAPersonne = new PublicationAPersonne();
String cle = itAuteur.next();
publiAPersonne.setIdPersonne(cle);
publiAPersonne.setIdPublication(publication.getId());
listeDesAuteurs.put(cle, publiAPersonne);
}
// - Envoyer au médiateur SSI personnes à supprimer
if (listeDesAuteurs.size() > 0) {
mediateur.supprimerPublicationAPersonne(this, listeDesAuteurs);
attenteSuppressionAuteursOk = true;
}
/*
attenteAjoutAuteursOk = false;
attenteSuppressionAuteursOk = false;
PersonneListe personnesInitiales = auteursInitialListe;
PersonneListe personnesActuelles = new PersonneListe();
if (auteurComboboxListe != null) {
Iterator<ComboBox<Personne>> itcp = auteurComboboxListe.iterator();
while (itcp.hasNext()) {
ComboBox<Personne> combobox = itcp.next();
Personne personne = combobox.getValue();
if (personne != null) {
personnesActuelles.put(personne.getId(), personne);
} else {
Debug.log("Etre valide :"+combobox.isValid()+" - "+combobox.getRawValue());
}
}
}
// Auteurs ajoutés
Iterator<String> clesActuelles = personnesActuelles.keySet().iterator();
while (clesActuelles.hasNext()) {
String idActuel = clesActuelles.next();
if (personnesInitiales.size() == 0 || personnesInitiales.get(idActuel) == null) {
Personne personne = personnesActuelles.get(idActuel);
PublicationAPersonne publicationAAuteur = new PublicationAPersonne();
if (mode.equals(Formulaire.MODE_MODIFIER)) {
publicationAAuteur.setIdPublication(publication.getId());
}
publicationAAuteur.setPersonne(personne);
publicationAAuteur.setIdRole(PublicationAPersonne.ROLE_AUTEUR);
//FIXME : auteursAjoutes.put(publicationAAuteur.getId(), publicationAAuteur);
attenteAjoutAuteursOk = true;
}
}
// Auteurs supprimés
if (mode.equals(Formulaire.MODE_MODIFIER)) {
Iterator<String> clesInitiales = personnesInitiales.keySet().iterator();
while (clesInitiales.hasNext()) {
String idInitial = clesInitiales.next();
if (personnesActuelles.size() == 0 || personnesActuelles.get(idInitial) == null) {
Personne personne = personnesInitiales.get(idInitial);
PublicationAPersonne publicationAAuteur = new PublicationAPersonne();
publicationAAuteur.setIdPublication(publication.getId());
publicationAAuteur.setPersonne(personne);
publicationAAuteur.setIdRole(PublicationAPersonne.ROLE_AUTEUR);
//FIXME : auteursSupprimes.put(publicationAAuteur.getId(), publicationAAuteur);
attenteSuppressionAuteursOk = true;
}
}
}
// Execution de les mise à jour pour le mode MODIFICATION
if (mode.equals(Formulaire.MODE_MODIFIER)) {
if (auteursAjoutes != null && auteursAjoutes.size() != 0) {
//FIXME : mediateur.ajouterPublicationAPersonne(this, publication.getId(), auteursAjoutes, PublicationAPersonne.ROLE_AUTEUR);
}
if (auteursSupprimes != null && auteursSupprimes.size() != 0) {
//FIXME : mediateur.supprimerPublicationAPersonne(this, auteursSupprimes);
}
}*/
}
public boolean verifierFormulaire() {
boolean valide = true;
ArrayList<String> messages = new ArrayList<String>();
// Tester si au moins un auteur est présent
if (grille.getStore().getModels().size() == 0) {
messages.add("Veuillez saisir au moins un auteur.");
}
String titre = titreChp.getValue();
if (titre == null || titre.equals("")) {
messages.add("Veuillez saisir le titre de la publication !");
}
String uri = uriChp.getValue();
if (uri != null && ! uri.isEmpty() && ! uri.matches(Pattern.url)) {
messages.add("L'URL saisie n'est pas valide !");
}
String datePublication = datePublicationChp.getRawValue();
if (datePublication == null || datePublication.equals("")) {
messages.add("Veuillez saisir une année de parution !");
} else {
if (!etreDateValide(datePublication)) {
messages.add("Le format de l'année saisie est incorrect !");
}
}
String pages = pagesChp.getValue();
String valeurPage = "(?:[0-9]+|[IVXLCDM]+|\\?)";
if (pages != null && ! pages.matches("^(?:"+valeurPage+"|"+valeurPage+"-"+valeurPage+")$")) {
messages.add("Le format des pages est incorrect !");
}
if (messages.size() != 0) {
String[] tableauDeMessages = {};
tableauDeMessages = messages.toArray(tableauDeMessages);
MessageBox.alert("Erreurs de saisies", UtilArray.implode(tableauDeMessages, "<br />"), null);
valide = false;
}
return valide;
}
private void peuplerFormulaire() {
setValeurComboProjets();
titreChp.setValue(publication.getTitre());
collectionChp.setValue(publication.getCollection());
uriChp.setValue(publication.getURI());
datePublicationChp.setValue(reduireDateParAnnee(publication.getDateParution()));
tomeChp.setValue(publication.getIndicationNvt());
fasciculeChp.setValue(publication.getFascicule());
pagesChp.setValue(publication.getPages());
if (publication.getEditeur().matches("^[0-9]+$")) {
editeurCombobox.getCombo().setValue(editeurCombobox.getStore().findModel("cs_id_structure", publication.getEditeur()));
} else {
editeurCombobox.getCombo().setRawValue(publication.getEditeur());
}
}
private Publication collecterPublication() {
Publication publicationCollectee = (Publication) publication.cloner(new Publication());
publicationCollectee.setIdProjet(getValeurComboProjets());
publicationCollectee.setAuteur(construireIntituleAuteur());
String titre = titreChp.getValue();
publicationCollectee.setTitre(titre);
String collection = collectionChp.getValue();
publicationCollectee.setCollection(collection);
publicationCollectee.setNomComplet(construireNomComplet());
String uri = uriChp.getValue();
publicationCollectee.setUri(uri);
String editeur = "";
if (editeurCombobox.getValeur() != null) {
Structure structure = new Structure(editeurCombobox.getValeur());
editeur = structure.getId();
publicationCollectee.setStructureEditeur(structure);
} else if (!UtilString.isEmpty(editeurCombobox.getCombo().getRawValue())) {
editeur = editeurCombobox.getCombo().getRawValue();
}
publicationCollectee.setEditeur(editeur);
String anneePublication = datePublicationChp.getRawValue();
String datePublication = anneePublication+"-00-00";
publicationCollectee.setDateParution(datePublication);
String tome = tomeChp.getValue();
publicationCollectee.setIndicationNvt(tome);
String fascicule = fasciculeChp.getValue();
publicationCollectee.setFascicule(fascicule);
String pages = pagesChp.getValue();
publicationCollectee.setPages(pages);
Publication publicationARetourner = null;
if (!publicationCollectee.comparer(publication)) {
publicationARetourner = publication = publicationCollectee;
}
return publicationARetourner;
}
private String construireIntituleEditeur() {
String editeur = "";
if (editeurCombobox.getValeur() != null) {
Structure structure = new Structure(editeurCombobox.getValeur());
editeur = structure.getNom();
} else if (!UtilString.isEmpty(editeurCombobox.getCombo().getRawValue())) {
editeur = editeurCombobox.getCombo().getRawValue();
}
return editeur;
}
private String construireIntituleAuteur() {
String intituleAuteur = "";
// TODO : ranger par ordre non-alphabétique
grille.getStore().sort("nom", SortDir.ASC);
List<Personne> auteurs = grille.getStore().getModels();
Iterator<Personne> itAuteurs = auteurs.iterator();
while (itAuteurs.hasNext()) {
Personne personneCourante = itAuteurs.next();
intituleAuteur += personneCourante.getNomComplet();
if (itAuteurs.hasNext()) {
intituleAuteur+=", ";
}
}
/*
* TO DELETE:int auteursNombre = auteurComboboxListe.size();
*
for (int i = 0; i < auteursNombre; i++) {
if (auteurComboboxListe.get(i).getValue() != null) {
Personne auteur = auteurComboboxListe.get(i).getValue();
inituleAuteur += auteur.getNom().toUpperCase()+ " "+auteur.getPrenom();
if (i != (auteursNombre - 1)) {
inituleAuteur += ", ";
}
}
}*/
return intituleAuteur;
}
private String construireNomComplet() {
// Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
String nomComplet = "";
String auteurs = construireIntituleAuteur();
String annee = datePublicationChp.getRawValue();
String titre = titreChp.getValue();
String editeur = construireIntituleEditeur();
nomComplet += auteurs+", "+annee+". "+titre+".";
if (!UtilString.isEmpty(editeur)) {
nomComplet += " Éditeur "+editeur+".";
}
if (collectionChp.getValue() != null) {
String revue = collectionChp.getValue();
nomComplet += ", "+revue;
}
if (fasciculeChp.getValue() != null) {
String fascicule = fasciculeChp.getValue();
nomComplet += ", "+fascicule;
}
if (tomeChp.getValue() != null) {
String tomaison = tomeChp.getValue();
nomComplet += ", "+tomaison;
}
if (collectionChp.getValue() != null || fasciculeChp.getValue() != null || tomeChp.getValue() != null) {
nomComplet += ".";
}
if (pagesChp.getValue() != null) {
String pages = pagesChp.getValue();
nomComplet += pages+".";
}
return nomComplet;
}
public void reinitialiserFormulaire() {
if (mode.equals(Formulaire.MODE_MODIFIER)) {
mediateur.afficherFormPublication(publication.getId());
} else {
mediateur.afficherFormPublication(null);
}
}
private boolean etreDateValide(String anneePublication) {
boolean valide = true;
if (!anneePublication.matches("^[0-2][0-9]{3}$")) {
valide = false;
}
return valide;
}
private String reduireDateParAnnee(String datePar) {
if (datePar.matches("^[0-2][0-9]{3}(-[0-9]{2}){2}$")) {
return datePar.split("-")[0];
} else {
return "";
}
}
private String getValeurComboProjets() {
String valeur = "";
if (projetsCombo.getValeur() != null) {
Projet projet = new Projet(projetsCombo.getValeur());
valeur = projet.getId();
}
return valeur;
}
private void setValeurComboProjets() {
if (projetsCombo.getStore() != null ) {
if (mode.equals(Formulaire.MODE_MODIFIER) && publication != null) {
projetsCombo.getCombo().setValue(projetsCombo.getStore().findModel("cpr_id_projet", publication.getIdProjet()));
} else if (mode.equals(Formulaire.MODE_AJOUTER)) {
projetsCombo.getCombo().setValue(projetsCombo.getStore().findModel("cpr_id_projet", mediateur.getProjetId()));
}
}
}
}