Subversion Repositories eFlore/Applications.coel

Compare Revisions

Ignore whitespace Rev 1427 → Rev 1428

/trunk/src/org/tela_botanica/client/vues/publication/PublicationForm.java
15,18 → 15,14
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.collection.CollectionAPersonne;
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.synchronisation.Sequenceur;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.Pattern;
39,21 → 35,19
 
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.SelectionChangedEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
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;
69,13 → 63,9
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;
90,19 → 80,24
 
public class PublicationForm extends Formulaire implements Rafraichissable {
//Variables de classe:
// Relatives à la publication
//-------------//
// ATTRIBUTS //
//-------------//
/** Publication **/
// on se sert d'un objet Publication lorsque l'on est en mode MODIFIER
private Publication publication;
// on se sert de l'identifiant d'une publication lorsque l'on est en mode AJOUTER
private String publicationId = null;
// Relatives aux auteurs
private PersonneListe auteursInitialListe = null;
private PersonneListe auteursAjoutes = null;
private PersonneListe auteursSupprimes = null;
/** Auteurs **/
private PublicationAPersonneListe auteursInitialListe = null;
private PublicationAPersonneListe auteursAjoutes = null;
private PublicationAPersonneListe auteursSupprimes = null;
private PublicationAPersonneListe auteursModifies = null;
private ContentPanel auteursFieldset = null;
private ChampComboBoxRechercheTempsReelPaginable projetsCombo = null;
private ArrayList<ComboBox<Personne>> auteurComboboxListe = null;
private ListStore<Personne> auteursStorePartage = null;
private FieldSet generalitesFieldset = null;
private TextField<String> titreChp = null;
119,15 → 114,23
private LayoutContainer zoneHaut, zoneBas;
private ToolBar barreOutils = null;
private EditorGrid<Personne> grille;
private EditorGrid<PublicationAPersonne> grilleAuteurs;
private ChampComboBoxRechercheTempsReelPaginable personnesSaisiesComboBox = null;
private Button personnesBoutonSupprimer = null;
private Button personnesBoutonModifier = null;
private PersonneListe listePersonne = new PersonneListe();
private Button boutonAuteurUp = null;
private Button boutonAuteurDown = null;
private FenetreForm fenetreFormulaire = null;
private Sequenceur sequenceur;
private String modeDeCreation = null;
boolean changeOrderMarker = false;
//----------------------//
// Constructeurs //------------------------------------------------------------
public PublicationForm(Mediateur mediateurCourrant, String publicationId) {
initialiserPublicationForm(mediateurCourrant, publicationId);
}
136,15 → 139,21
vueExterneARafraichirApresValidation = vueARafraichirApresValidation;
initialiserPublicationForm(mediateurCourrant, publicationId);
}
 
//-----------------------//
// Initialisation //------------------------------------------------------------
private void initialiserPublicationForm(Mediateur mediateurCourrant, String publicationId) {
sequenceur = new Sequenceur();
publication = new Publication();
publication.setId(publicationId);
auteursInitialListe = new PersonneListe();
this.publicationId = publicationId;
auteursInitialListe = new PublicationAPersonneListe();
initialiserAuteurs(); // Crée les listes d'auteurs ajoutés et supprimés
String modeDeCreation = (UtilString.isEmpty(publicationId) ? Formulaire.MODE_AJOUTER : Formulaire.MODE_MODIFIER);
// Si 'publicationId' est vide alors on est en mode "AJOUTER", sinon on est en mode "MODIFIER"
modeDeCreation = (UtilString.isEmpty(publicationId) ? Formulaire.MODE_AJOUTER : Formulaire.MODE_MODIFIER);
initialiserFormulaire(mediateurCourrant, modeDeCreation, MenuApplicationId.PUBLICATION);
panneauFormulaire.setLayout(new RowLayout());
panneauFormulaire.setStyleAttribute("padding", "0");
171,19 → 180,15
sequenceur.enfilerRafraichissement(this, new Information("chargement_modifier_ok"));
}
}
 
private void initialiserAuteurs() {
auteursAjoutes = new PublicationAPersonneListe();
auteursSupprimes = new PublicationAPersonneListe();
auteursModifies = new PublicationAPersonneListe();
}
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();
}
}
//-----------------------//
// User Interface //------------------------------------------------------------
private ToolBar creerBarreOutilsGrille() {
ToolBar barreOutils = new ToolBar();
211,8 → 216,95
Button rafraichirBouton = creerBoutonRafraichir();
barreOutils.add(rafraichirBouton);
barreOutils.add(new SeparatorToolItem());
barreOutils.add(new Text(i18nC.deplacerAuteur()));
boutonAuteurUp = creerBoutonAuteurUp();
barreOutils.add(boutonAuteurUp);
boutonAuteurDown = creerBoutonAuteurDown();
barreOutils.add(boutonAuteurDown);
return barreOutils;
}
public void actualiserEtatBoutonsBarreOutils() {
// Activation des boutons si la grille contient un élément
if (grilleAuteurs.getStore().getCount() > 0) {
personnesBoutonSupprimer.enable();
personnesBoutonModifier.enable();
}
// Désactivation des boutons si la grille ne contient plus d'élément
if (grilleAuteurs.getStore().getCount() == 0) {
personnesBoutonSupprimer.disable();
personnesBoutonModifier.disable();
}
}
private Button creerBoutonAuteurUp() {
Button bouton = new Button();
bouton.setIcon(Images.ICONES.arrowUp());
bouton.setEnabled(false);
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
if (grilleAuteurs.getSelectionModel().getSelectedItem() != null) {
PublicationAPersonne pap = grilleAuteurs.getSelectionModel().getSelectedItem();
int index = grilleAuteurs.getStore().indexOf(pap);
int newIndex = index;
newIndex--;
// le marqueur suivant est obligatoire sinon les évènements liés au magasin se
// déclenchent et posent problème
changeOrderMarker = true;
pap.setOrdreAuteurs(String.valueOf(newIndex+1));
PublicationAPersonne papSwitch = grilleAuteurs.getStore().getAt(index-1);
int newIndexPapSwitch = index + 1;
papSwitch.setOrdreAuteurs(String.valueOf(newIndexPapSwitch));
grilleAuteurs.getStore().update(papSwitch);
grilleAuteurs.getStore().remove(pap);
grilleAuteurs.getStore().insert(pap, newIndex);
changeOrderMarker = false;
grilleAuteurs.getSelectionModel().select(newIndex, true);
}
}
});
return bouton;
}
private Button creerBoutonAuteurDown() {
Button bouton = new Button();
bouton.setIcon(Images.ICONES.arrowDown());
bouton.setEnabled(false);
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
if (grilleAuteurs.getSelectionModel().getSelectedItem() != null) {
PublicationAPersonne pap = grilleAuteurs.getSelectionModel().getSelectedItem();
int index = grilleAuteurs.getStore().indexOf(pap);
int newIndex = index;
newIndex++;
// le marqueur suivant est obligatoire sinon les évènements liés au magasin se
// déclenchent et posent problème
changeOrderMarker = true;
pap.setOrdreAuteurs(String.valueOf(newIndex+1));
PublicationAPersonne papSwitch = grilleAuteurs.getStore().getAt(index+1);
int newIndexPapSwitch = index + 1;
papSwitch.setOrdreAuteurs(String.valueOf(newIndexPapSwitch));
grilleAuteurs.getStore().update(papSwitch);
grilleAuteurs.getStore().remove(pap);
grilleAuteurs.getStore().insert(pap, newIndex);
changeOrderMarker = false;
grilleAuteurs.getSelectionModel().select(newIndex, true);
}
}
});
return bouton;
}
 
private Button creerBoutonAjouter() {
Button bouton = new Button(i18nC.ajouter());
231,7 → 323,7
bouton.setIcon(Images.ICONES.vcardModifier());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
Personne personneSaisieSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem().getPersonne();
if (personneSaisieSelectionnee == null) {
InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
247,7 → 339,7
private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
String personneId = null;
if (mode.equals(Formulaire.MODE_MODIFIER)) {
Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
Personne personneSaisieSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem().getPersonne();
personneId = personneSaisieSelectionnee.getId();
}
301,11 → 393,11
bouton.setIcon(Images.ICONES.vcardSupprimer());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
if (personneSaisieSelectionnee == null) {
PublicationAPersonne personneSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem();
if (personneSelectionnee == null) {
InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
} else {
supprimerDansGrille(personneSaisieSelectionnee);
supprimerDansGrille(personneSelectionnee);
}
}
});
328,7 → 420,7
// FIXME : c'est la merde
//mediateur.selectionner(this, null, personneSelectionnee.getId(), "%");
} else {
grille.getStore().removeAll();
grilleAuteurs.getStore().removeAll();
layout();
}
}
338,6 → 430,8
modelTypePersonnes.setRoot("personnes");
modelTypePersonnes.setTotalName("nbElements");
modelTypePersonnes.addField("cp_fmt_nom_complet");
modelTypePersonnes.addField("cp_nom");
modelTypePersonnes.addField("cp_prenom");
modelTypePersonnes.addField("cp_id_personne");
modelTypePersonnes.addField("cp_code_postal");
modelTypePersonnes.addField("cp_ville");
349,17 → 443,17
personnesSaisiesComboBox = new ChampComboBoxRechercheTempsReelPaginable(proxyPersonnes, modelTypePersonnes, displayNamePersonnes);
personnesSaisiesComboBox.getCombo().addListener(Events.Select, new Listener<BaseEvent>() {
public void handleEvent(BaseEvent be) {
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) {
PublicationAPersonne pap = new PublicationAPersonne();
pap.setPersonne(personneSaisieSelectionnee);
if (modeDeCreation != Formulaire.MODE_AJOUTER) pap.setPublicationLiee(publication);
if (grilleAuteurs.getStore().findModel(pap) != 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);
ajouterDansGrille(pap);
personnesSaisiesComboBox.getCombo().setValue(null);
}
}
367,29 → 461,25
});
}
private void obtenirPersonnesSaisies(String nom) {
mediateur.selectionnerPersonneParNomComplet(this, null, nom+"%", null);
private void ajouterDansGrille(PublicationAPersonne pap) {
ajouterDansGrille(pap, 0);
}
private void ajouterDansGrille(Personne personne) {
ajouterDansGrille(personne, 0);
}
private void ajouterDansGrille(Personne personne, int index) {
if (personne != null) {
if (!grille.getStore().contains(personne)) {
private void ajouterDansGrille(PublicationAPersonne pap, int index) {
if (pap != null) {
if (!grilleAuteurs.getStore().contains(pap)) {
//1) si elle ne fait pas partie des initiaux, ajouter à la liste à ajouter
if (!auteursInitialListe.containsValue(personne)) {
auteursAjoutes.put(personne.getId(), personne);
if (!auteursInitialListe.containsValue(pap)) {
auteursAjoutes.put(pap.getId(), pap);
}
// L'enlever de la liste à supprimer
if (auteursSupprimes.containsValue(personne)) {
auteursSupprimes.remove(personne);
if (auteursSupprimes.containsValue(pap)) {
auteursSupprimes.remove(pap);
}
//2) Ajouter a la grille
grille.getStore().insert(personne, index);
grille.getSelectionModel().select(index, false);
grilleAuteurs.getStore().insert(pap, index);
grilleAuteurs.getSelectionModel().select(index, false);
} else {
InfoLogger.display("Information", "La personne choisie existe déjà dans la liste.");
}
399,73 → 489,136
/**
* 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);
private void supprimerDansGrille(PublicationAPersonne pap) {
if (pap != null) {
// 1) Ajouter a la liste des personne à supprimer uniquement si est présente dans la liste initiale
if (auteursInitialListe.containsValue(pap)) {
auteursSupprimes.put(pap.getId(), pap);
}
if (auteursAjoutes.containsValue(personne)) {
auteursAjoutes.remove(personne);
if (auteursAjoutes.containsValue(pap)) {
auteursAjoutes.remove(pap);
}
//2) Supprimer la personne de la liste
grille.getStore().remove(personne);
if (auteursModifies.containsValue(pap)) {
auteursModifies.remove(pap);
}
// 2) Supprimer la personne de la liste
grilleAuteurs.getStore().remove(pap);
} else {
Info.display("Information", "Vous devez sélectionner une personne");
}
}
private EditorGrid<Personne> creerGrille() {
private EditorGrid<PublicationAPersonne> creerGrilleAuteurs() {
ListStore<Personne> storeGrille = new ListStore<Personne>();
storeGrille.addListener(Store.Add, new Listener<StoreEvent<Personne>>() {
public void handleEvent(StoreEvent<Personne> ce) {
actualiserEtatBoutonsBarreOutils();
ListStore<PublicationAPersonne> storeGrilleAuteurs = new ListStore<PublicationAPersonne>();
// ADD Listener ------------------------------------------------------------------------------------
storeGrilleAuteurs.addListener(Store.Add, new Listener<StoreEvent<PublicationAPersonne>>() {
public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
if (!changeOrderMarker) {
// Bug de GXT : Pour récupérer l'élément modifié, j'ai dû faire comme suit
ListStore<PublicationAPersonne> auteursStore = (ListStore<PublicationAPersonne>)ce.getSource();
PublicationAPersonne pap = auteursStore.getAt(ce.getIndex());
// Lorsque l'on reçoit une liste d'auteurs, on leur affecte l'état "modifié", puis
// on les ajoute au magasin mais puisque chaque élément ajouté au magasin déclenche
// l'évènement Store.Add, on est obligé de vérifier si l'objet n'a pas déjà un état
// sinon l'évènement écrase l'état précédent
if (pap.get("_etat_") == null) pap.set("_etat_", aDonnee.ETAT_AJOUTE);
actualiserEtatBoutonsBarreOutils();
}
}
});
storeGrille.addListener(Store.Remove, new Listener<StoreEvent<Personne>>() {
public void handleEvent(StoreEvent<Personne> ce) {
actualiserEtatBoutonsBarreOutils();
// REMOVE Listener ------------------------------------------------------------------------------------
storeGrilleAuteurs.addListener(Store.Remove, new Listener<StoreEvent<PublicationAPersonne>>() {
public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
if (!changeOrderMarker) {
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);
// UPDATE Listener ------------------------------------------------------------------------------------
storeGrilleAuteurs.addListener(Store.Update, new Listener<StoreEvent<PublicationAPersonne>>() {
public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
if (!changeOrderMarker) {
if (ce.getRecord().isModified("ordre")) {
/** s'il s'agit d'un auteur que l'on vient d'ajouter à la liste, alors on a pas besoin
de faire quoique ce soit car l'auteur est déjà dans la liste des auteurs ajoutés **/
if (ce.getModel().get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
// ... do nothing
/** s'il s'agit d'un auteur qui était déjà présent dans la liste initiale, il faut
ajouter cet auteur à la liste des auteurs modifiés **/
} else {
if (ce.getModel() instanceof PublicationAPersonne) {
PublicationAPersonne pap = ce.getModel();
auteursModifies.put(pap.getId(), pap);
}
}
}
}
}
});
});
List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
ColumnConfig columnOrdre = new ColumnConfig("ordre", i18nC.ordre(), 15);
/*
final TextField<String> ordre = new TextField<String>();
ordre.setValidator(new Validator(){
public String validate(Field<?> field, String value) {
if (value.matches("[0-9]*")) return null;
else return "[Erreur] Le champ 'ordre' doit être un nombre entier.";
}
});
*/
 
colonnes.add(columnOrdre);
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>();
GridSelectionModel<PublicationAPersonne> modeleDeSelection = new GridSelectionModel<PublicationAPersonne>();
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);
EditorGrid<PublicationAPersonne> grilleDesAuteurs = new EditorGrid<PublicationAPersonne>(storeGrilleAuteurs, modeleDeColonnes);
return grillePublications;
modeleDeSelection.addListener(Events.SelectionChange, new SelectionChangedListener<PublicationAPersonne>() {
public void selectionChanged(SelectionChangedEvent<PublicationAPersonne> se) {
PublicationAPersonne papSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem();
int index = grilleAuteurs.getStore().indexOf(papSelectionnee);
if (index >= 1) boutonAuteurUp.setEnabled(true);
else boutonAuteurUp.setEnabled(false);
if ((index+1) < grilleAuteurs.getStore().getCount()) boutonAuteurDown.setEnabled(true);
else boutonAuteurDown.setEnabled(false);
}
});
grilleDesAuteurs.setHeight("100%");
grilleDesAuteurs.setBorders(true);
grilleDesAuteurs.setSelectionModel(modeleDeSelection);
grilleDesAuteurs.getView().setForceFit(true);
grilleDesAuteurs.setAutoExpandColumn("fmt_nom_complet");
grilleDesAuteurs.setStripeRows(true);
grilleDesAuteurs.setTrackMouseOver(true);
return grilleDesAuteurs;
}
private void genererTitreFormulaire() {
485,9 → 638,6
auteursFieldset.setLayout(new FitLayout());
auteursFieldset.setHeading("Auteurs");
auteurComboboxListe = new ArrayList<ComboBox<Personne>>(0);
mediateur.clicObtenirListeAuteurs(this);
creerChampsAuteur();
}
495,30 → 645,11
auteursFieldset.removeAll();
barreOutils = creerBarreOutilsGrille();
auteursFieldset.setTopComponent(barreOutils);
grille = creerGrille();
auteursFieldset.add(grille);
grilleAuteurs = creerGrilleAuteurs();
auteursFieldset.add(grilleAuteurs);
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);
588,7 → 719,6
editionFieldset.setCollapsible(true);
editionFieldset.setLayout(layout);
 
/*****************************************************/
/** Champ 'Editeur de la publication' **/
/*****************************************************/
642,121 → 772,30
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
publication = (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);
}
}
private void synchronisation() {
}
//-------------------------//
// Méthodes privées //------------------------------------------------------------
private void miseAJourAuteursInitialListe() {
Iterator<String> clesAjoutees = auteursAjoutes.keySet().iterator();
while (clesAjoutees.hasNext()) {
Personne auteurAjoute = auteursAjoutes.get(clesAjoutees.next());
PublicationAPersonne 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());
PublicationAPersonne auteurSupprime = auteursSupprimes.get(clesSupprimees.next());
auteursInitialListe.remove(auteurSupprime.getId());
}
}
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());
layout();
}
private void rafraichirInformation(Information info) {
String type = info.getType();
if (type.equals("publication_enregistree")) {
// la publication vien d'etre enregistrée, on soumet les auteurs
soumettreAuteurs();
} else if (type.equals("auteurs_enregistres")) {
miseAJourAuteursInitialListe();
initialiserAuteurs();
repandreRafraichissement();
controlerFermeture();
} else if (type.equals("chargement_modifier_ok")) {
peuplerFormulaire();
genererTitreFormulaire();
}
/*if (info.getType().equals("liste_personne")) {
PersonneListe listePersonneAuteur = (PersonneListe) info.getDonnee(0);
ListStore store = personnesSaisiesComboBox.getStore();
store.removeAll();
store.add(listePersonneAuteur.toList());
} else */
if (type.equals("personne_ajoutee")) {
if (info.getDonnee(0) != null) {
Personne personne = (Personne) info.getDonnee(0);
ajouterDansGrille(personne);
}
} else if (type.equals("personne_modifiee")) {
if (info.getDonnee(0) != null) {
Personne personne = (Personne) info.getDonnee(0);
Personne personneDansGrille = grille.getStore().findModel("id_personne", personne.getId());
int index = grille.getStore().indexOf(personneDansGrille);
grille.getStore().remove(personneDansGrille);
ajouterDansGrille(personne, index);
}
} 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 void initialiserAuteurs() {
auteursAjoutes = new PersonneListe();
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() {
boolean formulaireValideOk = verifierFormulaire();
if (formulaireValideOk) {
soumettrePublication();
}
return formulaireValideOk;
}
 
763,8 → 802,7
private void soumettrePublication() {
Publication publicationCollectee = collecterPublication();
if (publicationCollectee != null) {
// Pour l'enregistrement des collections, on utilise le séquenceur
// Pour l'enregistrement des publications, on utilise le séquenceur
// Il doit attendre le retour de l'enregistrement pour poursuivre
sequenceur = new Sequenceur();
int seqId = sequenceur.lancerRequeteSynchrone(this);
773,94 → 811,81
} else if (mode.equals(Formulaire.MODE_MODIFIER)) {
mediateur.modifierPublication(sequenceur, publicationCollectee, seqId);
}
sequenceur.enfilerRafraichissement(this, new Information("publication_enregistree"));
// si l'on est en mode MODIFIER, on soumet les auteurs meme si les informations de la publication
// restent inchangées car il se peut que les auteurs aient été modifiés
} else if (mode.equals(Formulaire.MODE_MODIFIER)) {
soumettreAuteurs();
}
}
private void soumettreAuteurs() {
formaterOrdreAuteurs();
//1) Auteurs ajoutés :
// - Créer une PublicationAAuteurListe
PublicationAPersonneListe listeDesAuteurs = new PublicationAPersonneListe();
PublicationAPersonneListe listeAuteursAAjouter = new PublicationAPersonneListe();
Iterator<String> itAuteur = auteursAjoutes.keySet().iterator();
while (itAuteur.hasNext()) {
PublicationAPersonne publiAPersonne = new PublicationAPersonne();
while (itAuteur.hasNext()) {
String cle = itAuteur.next();
publiAPersonne.setIdPersonne(cle);
publiAPersonne.setIdPublication(publication.getId());
listeDesAuteurs.put(cle, publiAPersonne);
PublicationAPersonne publiAPersonne = auteursAjoutes.get(cle);
publiAPersonne.setIdPublication(this.publicationId);
publiAPersonne.setOrdreAuteurs(publiAPersonne.getOrdreAuteurs());
listeAuteursAAjouter.put(cle, publiAPersonne);
}
// - envoyer au mediateur SSI personnes à ajouter
if (listeDesAuteurs.size() > 0) {
if (listeAuteursAAjouter.size() > 0) {
int seqId = sequenceur.lancerRequeteSynchrone(this);
mediateur.ajouterPublicationAPersonne(sequenceur, publication.getId(), listeDesAuteurs, PublicationAPersonne.ROLE_AUTEUR, seqId);
//attenteAjoutAuteursOk = true;
mediateur.ajouterPublicationAPersonne(sequenceur, this.publicationId, listeAuteursAAjouter, PublicationAPersonne.ROLE_AUTEUR, seqId);
}
//2) Auteurs supprimés :
// - Créer une PublicationAPersonneListe
listeDesAuteurs = new PublicationAPersonneListe();
PublicationAPersonneListe listeAuteursASupprimer = 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);
PublicationAPersonne publiAPersonne = auteursSupprimes.get(cle);
listeAuteursASupprimer.put(cle, publiAPersonne);
}
// - Envoyer au médiateur SSI personnes à supprimer
if (listeDesAuteurs.size() > 0) {
if (listeAuteursASupprimer.size() > 0) {
// Pour une suppression des auteurs, on a pas besoin d'attendre le retour
mediateur.supprimerPublicationAPersonne(this, listeDesAuteurs);
//attenteSuppressionAuteursOk = true;
mediateur.supprimerPublicationAPersonne(this, listeAuteursASupprimer);
}
sequenceur.enfilerRafraichissement(this, new Information("auteurs_enregistres"));
}
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.");
//3) Auteurs modifiés :
PublicationAPersonneListe listeAuteursAModifier = new PublicationAPersonneListe();
itAuteur = auteursModifies.keySet().iterator();
while (itAuteur.hasNext()) {
String cle = itAuteur.next();
PublicationAPersonne publiAPersonne = auteursModifies.get(cle);
listeAuteursAModifier.put(cle, publiAPersonne);
}
String titre = titreChp.getValue();
if (titre == null || titre.equals("")) {
messages.add("Veuillez saisir le titre de la publication !");
// - Envoyer au médiateur SSI personnes à modifier
if (listeAuteursAModifier.size() > 0) {
int seqId = sequenceur.lancerRequeteSynchrone(this);
mediateur.modifierPublicationAPersonne(sequenceur, publication.getId(), listeAuteursAModifier, PublicationAPersonne.ROLE_AUTEUR, seqId);
}
String uri = uriChp.getValue();
if (uri != null && ! uri.isEmpty() && ! uri.matches(Pattern.url)) {
messages.add("L'URL saisie n'est pas valide !");
}
sequenceur.enfilerRafraichissement(this, new Information("auteurs_enregistres"));
}
private void formaterOrdreAuteurs() {
ListStore<PublicationAPersonne> store = grilleAuteurs.getStore();
List<PublicationAPersonne> auteurs = grilleAuteurs.getStore().getModels();
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 !");
Iterator<PublicationAPersonne> itAuteurs = auteurs.iterator();
while (itAuteurs.hasNext()) {
PublicationAPersonne pap = itAuteurs.next();
int ordre = store.indexOf(pap) + 1;
if (pap.getOrdreAuteurs() != String.valueOf(ordre)) {
pap.setOrdreAuteurs(String.valueOf(ordre));
auteursModifies.put(pap.getId(), pap);
}
}
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() {
881,7 → 906,7
}
private Publication collecterPublication() {
 
Publication publicationCollectee = (Publication) publication.cloner(new Publication());
publicationCollectee.setIdProjet(getValeurComboProjets());
publicationCollectee.setAuteur(construireIntituleAuteur());
931,7 → 956,8
String editeur = "";
if (editeurCombobox.getValeur() != null) {
Structure structure = new Structure(editeurCombobox.getValeur());
editeur = structure.getNom();
if (structure == null) editeur = editeurCombobox.getCombo().getRawValue();
else editeur = structure.getNom();
} else if (!UtilString.isEmpty(editeurCombobox.getCombo().getRawValue())) {
editeur = editeurCombobox.getCombo().getRawValue();
}
941,13 → 967,13
private String construireIntituleAuteur() {
String intituleAuteur = "";
// TODO : ranger par ordre non-alphabétique
grille.getStore().sort("nom", SortDir.ASC);
List<Personne> auteurs = grille.getStore().getModels();
// ranger par ordre désigné par le champ 'cpuap_ordre' de la table PublicationAPersonne
grilleAuteurs.getStore().sort("ordre", SortDir.ASC);
List<PublicationAPersonne> auteurs = grilleAuteurs.getStore().getModels();
Iterator<Personne> itAuteurs = auteurs.iterator();
Iterator<PublicationAPersonne> itAuteurs = auteurs.iterator();
while (itAuteurs.hasNext()) {
Personne personneCourante = itAuteurs.next();
Personne personneCourante = itAuteurs.next().getPersonne();
intituleAuteur += personneCourante.getNom().toUpperCase() + " " + personneCourante.getPrenom();
if (itAuteurs.hasNext()) {
intituleAuteur+=", ";
1021,6 → 1047,56
}
}
//---------------------------//
// Méthodes publiques //------------------------------------------------------------
public boolean verifierFormulaire() {
boolean valide = true;
ArrayList<String> messages = new ArrayList<String>();
// Tester si au moins un auteur est présent
if (grilleAuteurs.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;
}
//-------------------//
// Accesseurs //------------------------------------------------------------
private String getValeurComboProjets() {
String valeur = "";
if (projetsCombo.getValeur() != null) {
1038,4 → 1114,99
}
}
}
//-------------------//
// Rafraichir //------------------------------------------------------------
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof Publication) {
publication = (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);
}
}
private void rafraichirListeAuteurs(PublicationAPersonneListe auteurs) {
Iterator<String> it = auteurs.keySet().iterator();
while (it.hasNext()) {
PublicationAPersonne auteur = auteurs.get(it.next());
auteur.set("_etat_", aDonnee.ETAT_MODIFIE);
auteursInitialListe.put(auteur.getId(), auteur);
}
grilleAuteurs.getStore().removeAll();
grilleAuteurs.getStore().add(auteursInitialListe.toList());
grilleAuteurs.getStore().sort("ordre", SortDir.ASC);
layout();
}
private void rafraichirInformation(Information info) {
String type = info.getType();
if (type.equals("auteurs_enregistres")) {
miseAJourAuteursInitialListe();
initialiserAuteurs();
repandreRafraichissement();
controlerFermeture();
} else if (type.equals("chargement_modifier_ok")) {
peuplerFormulaire();
genererTitreFormulaire();
}
 
if (type.equals("personne_ajoutee")) {
if (info.getDonnee(0) != null) {
Personne personne = (Personne) info.getDonnee(0);
PublicationAPersonne pap = new PublicationAPersonne();
pap.setPersonne(personne);
if (modeDeCreation != Formulaire.MODE_AJOUTER) pap.setPublicationLiee(publication);
ajouterDansGrille(pap);
}
} else if (type.equals("personne_modifiee")) {
if (info.getDonnee(0) != null) {
// créer la nouvelle entrée
Personne personne = (Personne) info.getDonnee(0);
PublicationAPersonne pap = new PublicationAPersonne();
pap.setPersonne(personne);
if (modeDeCreation != Formulaire.MODE_AJOUTER) pap.setPublicationLiee(publication);
// supprimer l'entrée précédente
PublicationAPersonne personneDansGrille = grilleAuteurs.getStore().findModel("id_personne", personne.getId());
int index = grilleAuteurs.getStore().indexOf(personneDansGrille);
grilleAuteurs.getStore().remove(personneDansGrille);
// ajouter la nouvelle entrée dans la grille
ajouterDansGrille(pap, index);
}
} else if (info.getType().equals("modif_publication")) {
InfoLogger.display("Modification d'une publication", info.toString());
soumettreAuteurs();
} 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 idPublication = (String) info.getDonnee(0);
this.publicationId = idPublication;
soumettreAuteurs();
InfoLogger.display("Ajout d'une publication", "La publication '"+publicationId+"' a bien été ajoutée");
} else {
InfoLogger.display("Ajout d'une publication", info.toString());
}
}
}
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);
}
}
}