| New file |
|---|
| 0,0 → 1,1191 |
|---|
| package org.tela_botanica.client.vues.publication; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| 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.GrillePaginable; |
| import org.tela_botanica.client.composants.InfoLogger; |
| import org.tela_botanica.client.composants.pagination.ProxyPersonnes; |
| import org.tela_botanica.client.composants.pagination.ProxyPersonnesAPublication; |
| 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.aDonnee; |
| import org.tela_botanica.client.modeles.personne.Personne; |
| 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.synchronisation.Sequenceur; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.Log; |
| 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.data.BaseModelData; |
| import com.extjs.gxt.ui.client.data.LoadEvent; |
| import com.extjs.gxt.ui.client.data.Loader; |
| 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.Events; |
| 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.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.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.grid.ColumnConfig; |
| import com.extjs.gxt.ui.client.widget.grid.ColumnModel; |
| import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel; |
| 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; |
| |
| |
| public class PublicationForm extends Formulaire implements Rafraichissable { |
| |
| //-------------// |
| // 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; |
| |
| /** Auteurs **/ |
| private PublicationAPersonneListe auteursInitialListe = null; |
| private PublicationAPersonneListe auteursAjoutes = null; |
| private PublicationAPersonneListe auteursSupprimes = null; |
| private PublicationAPersonneListe auteursModifies = null; |
| |
| private ContentPanel auteursFieldset = null; |
| |
| 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 TextField<String> datePublicationChp = null; |
| private TextField<String> tomeChp = null; |
| private TextField<String> fasciculeChp = null; |
| private TextField<String> pagesChp = null; |
| |
| private LayoutContainer zoneHaut, zoneBas; |
| |
| private ToolBar barreOutils = null; |
| private GrillePaginable<ModelData> grilleAuteurs; |
| private ChampComboBoxRechercheTempsReelPaginable personnesSaisiesComboBox = null; |
| private Button personnesBoutonSupprimer = null; |
| private Button personnesBoutonModifier = null; |
| 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); |
| } |
| |
| public PublicationForm(Mediateur mediateurCourrant, String publicationId, Rafraichissable vueARafraichirApresValidation) { |
| vueExterneARafraichirApresValidation = vueARafraichirApresValidation; |
| initialiserPublicationForm(mediateurCourrant, publicationId); |
| } |
| |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Initialisation |
| |
| private void initialiserPublicationForm(Mediateur mediateurCourrant, String publicationId) { |
| sequenceur = new Sequenceur(); |
| publication = new Publication(); |
| publication.setId(publicationId); |
| this.publicationId = publicationId; |
| auteursInitialListe = new PublicationAPersonneListe(); |
| initialiserAuteurs(); // Crée les listes d'auteurs ajoutés et supprimés |
| |
| // 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"); |
| panneauFormulaire.setHeight(600); |
| |
| zoneHaut = new LayoutContainer(new FitLayout()); |
| zoneBas = new LayoutContainer(new FlowLayout()); |
| panneauFormulaire.add(zoneHaut, new RowData(0.99, 0.45)); |
| panneauFormulaire.add(zoneBas, new RowData(0.99, 0.55)); |
| 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, sequenceur); |
| sequenceur.enfilerRafraichissement(this, new Information("chargement_modifier_ok")); |
| } |
| } |
| |
| private void initialiserAuteurs() { |
| auteursAjoutes = new PublicationAPersonneListe(); |
| auteursSupprimes = new PublicationAPersonneListe(); |
| auteursModifies = new PublicationAPersonneListe(); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // User Interface |
| |
| private ToolBar creerBarreOutilsGrille() { |
| ToolBar barreOutils = new ToolBar(); |
| |
| Button ajouterBouton = creerBoutonAjouter(); |
| barreOutils.add(ajouterBouton); |
| |
| 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); |
| |
| 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.getGrille().getSelectionModel().getSelectedItem() != null) { |
| mettreAJourOrdreAuteur(-1); |
| } |
| } |
| }); |
| 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) { |
| mettreAJourOrdreAuteur(+1); |
| } |
| } |
| }); |
| return bouton; |
| } |
| |
| private void formaterOrdreAuteurs() { |
| List<ModelData> auteurs = grilleAuteurs.getStore().getModels(); |
| Iterator<ModelData> itAuteurs = auteurs.iterator(); |
| while (itAuteurs.hasNext()) { |
| ModelData selection = itAuteurs.next(); |
| PublicationAPersonne pap = new PublicationAPersonne(selection, false); |
| |
| String ordre = String.valueOf(grilleAuteurs.getStore().indexOf(selection) + 1); |
| if (pap.getOrdreAuteurs() != ordre) { |
| selection.set("_ordre_", ordre); |
| grilleAuteurs.getStore().update(selection); |
| pap.setOrdreAuteurs(ordre); |
| auteursModifies.put(pap.getId(), pap); |
| } |
| } |
| } |
| |
| private void mettreAJourOrdreAuteur(int monterOuDescendre) { |
| ModelData publiAPersonneSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem(); |
| int index = grilleAuteurs.getStore().indexOf(publiAPersonneSelectionnee); |
| int nouvelIndex = index + monterOuDescendre; |
| |
| if (verifierOrdreAuteur(nouvelIndex)) { |
| // le marqueur suivant est obligatoire sinon les évènements liés au magasin se |
| // déclenchent et posent problème |
| changeOrderMarker = true; |
| |
| int indexAPermuter = index + monterOuDescendre; |
| ModelData publiAPersonneSwitch = grilleAuteurs.getStore().getAt(indexAPermuter); |
| String ordreAPermuter = String.valueOf((indexAPermuter + 1) - monterOuDescendre); |
| publiAPersonneSwitch.set("_ordre_", ordreAPermuter); |
| grilleAuteurs.getStore().update(publiAPersonneSwitch); |
| PublicationAPersonne papSwitch = new PublicationAPersonne(publiAPersonneSwitch, false); |
| papSwitch.setOrdreAuteurs(ordreAPermuter); |
| auteursModifies.put(papSwitch.getId(), papSwitch); |
| |
| grilleAuteurs.getStore().remove(publiAPersonneSelectionnee); |
| String nouvelOrdre = String.valueOf((index + 1) + monterOuDescendre); |
| publiAPersonneSelectionnee.set("_ordre_", nouvelOrdre); |
| grilleAuteurs.getStore().insert(publiAPersonneSelectionnee, nouvelIndex); |
| PublicationAPersonne papSelectionnee = new PublicationAPersonne(publiAPersonneSelectionnee, false); |
| papSelectionnee.setOrdreAuteurs(nouvelOrdre); |
| auteursModifies.put(papSelectionnee.getId(), papSelectionnee); |
| changeOrderMarker = false; |
| |
| grilleAuteurs.getSelectionModel().select(nouvelIndex, false); |
| } |
| } |
| |
| private boolean verifierOrdreAuteur(int nouvelIndex) { |
| int nbrElement = grilleAuteurs.getStore().getCount(); |
| boolean ok = true; |
| if (nouvelIndex < 0 || nouvelIndex >= nbrElement) { |
| ok = false; |
| } |
| return ok; |
| } |
| |
| private void activerBoutonsOrdreAuteur() { |
| ModelData papSelectionnee = grilleAuteurs.getGrille().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); |
| } |
| } |
| |
| 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 = new PublicationAPersonne(grilleAuteurs.getSelectionModel().getSelectedItem(), false).getPersonne(); |
| |
| 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 = new PublicationAPersonne(grilleAuteurs.getSelectionModel().getSelectedItem(), false).getPersonne(); |
| 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.setHeadingHtml(panneauFormulaire.getHeadingHtml()); |
| 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(); |
| } |
| } |
| }; |
| |
| 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) { |
| supprimerDansGrille(); |
| } |
| }); |
| 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 |
| grilleAuteurs.reload(); |
| } else { |
| grilleAuteurs.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_nom"); |
| modelTypePersonnes.addField("cp_prenom"); |
| 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>(null); |
| |
| 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()); |
| Log.debug("Récupération info combo :"+personneSaisieSelectionnee.toString()); |
| PublicationAPersonne pap = new PublicationAPersonne(aDonnee.GARDER_PREFIXE); |
| pap.setPersonne(personneSaisieSelectionnee, aDonnee.INTEGRER_PROPRIETES); |
| pap.setOrdreAuteurs(String.valueOf(grilleAuteurs.getStore().getCount()+1)); |
| if (modeDeCreation != Formulaire.MODE_AJOUTER) { |
| pap.setPublicationLiee(publication); |
| pap.setIdPublication(publicationId); |
| } |
| pap.setIdRole(PublicationAPersonne.ROLE_AUTEUR); |
| Log.debug("Récupération info combo pap id :"+pap.getId()); |
| |
| if (ajouterDansGrille(pap)) { |
| personnesSaisiesComboBox.getCombo().setValue(null); |
| } |
| } |
| } |
| }); |
| } |
| |
| private boolean ajouterDansGrille(PublicationAPersonne pap) { |
| return ajouterDansGrille(pap, grilleAuteurs.getStore().getCount()); |
| } |
| |
| private boolean ajouterDansGrille(PublicationAPersonne pap, int index) { |
| boolean ok = false; |
| if (pap != null) { |
| Log.debug("Début ajout dans grille :"+pap.toString()); |
| if (grilleAuteurs.getStore().contains((ModelData) pap)) { |
| InfoLogger.display("Information", "La personne choisie existe déjà dans la liste d'auteurs."); |
| } else { |
| // 1) si elle ne fait pas partie des initiaux, ajouter à la liste à ajouter |
| if (!auteursInitialListe.containsValue(pap)) { |
| auteursAjoutes.put(pap.getId(), pap); |
| Log.debug("Ajout dans grille -> auteur '"+pap.getId()+"' a été ajouté à la liste des ajoutés (il ne fait pas parti de la liste initiale)."); |
| } |
| |
| // L'enlever de la liste à supprimer |
| if (auteursSupprimes.containsValue(pap)) { |
| auteursSupprimes.remove(pap); |
| Log.debug("Ajout dans grille -> auteur '"+pap.getId()+"' a été retiré de la liste des supprimés."); |
| } |
| |
| // 2) Ajouter a la grille |
| grilleAuteurs.getStore().insert((ModelData) pap, index); |
| grilleAuteurs.getSelectionModel().select(index, false); |
| ok = true; |
| } |
| } |
| return ok; |
| } |
| |
| private void supprimerDansGrille() { |
| List<ModelData> listeDonneesSelectionnees = grilleAuteurs.getSelectionModel().getSelectedItems(); |
| for (ModelData donneeSelectionnee : listeDonneesSelectionnees) { |
| supprimerAuteurDansGrille(donneeSelectionnee); |
| } |
| } |
| |
| private void supprimerAuteurDansGrille(ModelData donneeSelectionnee) { |
| PublicationAPersonne personneSelectionnee = new PublicationAPersonne(donneeSelectionnee, aDonnee.GARDER_PREFIXE); |
| Log.debug("Début supprimer auteur dans grille : "+personneSelectionnee.toString()); |
| if (personneSelectionnee.getId() == null) { |
| InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerAuteur()); |
| } else { |
| // 1) Ajouter a la liste des personne à supprimer uniquement si est présente dans la liste initiale |
| if (auteursInitialListe.containsKey(personneSelectionnee.getId())) { |
| auteursSupprimes.put(personneSelectionnee.getId(), personneSelectionnee); |
| Log.debug("Ajout Personne à supprimer : "+auteursSupprimes.toString()); |
| } |
| |
| if (auteursAjoutes.containsKey(personneSelectionnee.getId())) { |
| auteursAjoutes.remove(personneSelectionnee.getId()); |
| } |
| |
| if (auteursModifies.containsKey(personneSelectionnee.getId())) { |
| auteursModifies.remove(personneSelectionnee.getId()); |
| } |
| |
| // 2) Supprimer la personne de la liste |
| Log.debug("Personne trouvée : "+grilleAuteurs.getStore().findModel(donneeSelectionnee).toString()); |
| grilleAuteurs.getStore().remove(donneeSelectionnee); |
| formaterOrdreAuteurs(); |
| } |
| } |
| |
| private GrillePaginable<ModelData> creerGrilleAuteurs() { |
| // ModelType |
| ModelType modelTypePersonnesAPublication = new ModelType(); |
| modelTypePersonnesAPublication.setRoot("publicationsAPersonne"); |
| modelTypePersonnesAPublication.setTotalName("nbElements"); |
| modelTypePersonnesAPublication.addField("cpuap_id_personne"); |
| modelTypePersonnesAPublication.addField("cpuap_id_publication"); |
| modelTypePersonnesAPublication.addField("cpuap_id_role"); |
| modelTypePersonnesAPublication.addField("cpuap_ordre"); |
| modelTypePersonnesAPublication.addField("cp_id_personne"); |
| modelTypePersonnesAPublication.addField("cp_fmt_nom_complet"); |
| modelTypePersonnesAPublication.addField("cp_nom"); |
| modelTypePersonnesAPublication.addField("cp_prenom"); |
| modelTypePersonnesAPublication.addField("cp_id_personne"); |
| modelTypePersonnesAPublication.addField("cp_code_postal"); |
| modelTypePersonnesAPublication.addField("cp_ville"); |
| modelTypePersonnesAPublication.addField("cp_truk_courriel"); |
| |
| // Proxy |
| ProxyPersonnesAPublication<ModelData> proxyPersonnesAPublication = new ProxyPersonnesAPublication<ModelData>(null, publicationId); |
| |
| // Colonnes |
| List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>(); |
| ColumnConfig columnOrdre = new ColumnConfig("_ordre_", i18nC.ordre(), 15); |
| colonnes.add(columnOrdre); |
| colonnes.add(new ColumnConfig("cp_fmt_nom_complet", i18nC.personneNomComplet(), 150)); |
| colonnes.add(new ColumnConfig("cp_code_postal", i18nC.personneCodePostal(), 150)); |
| colonnes.add(new ColumnConfig("cp_ville", i18nC.personneVille(), 75)); |
| colonnes.add(new ColumnConfig("cp_truk_courriel", i18nC.personneCourriel(), 75)); |
| |
| // Champs de traitement |
| HashMap<String, String> virtualFields = new HashMap<String, String>(); |
| virtualFields.put("_ordre_", "cpuap_ordre"); |
| |
| // Modele de selection |
| GridSelectionModel<ModelData> modeleDeSelection = new GridSelectionModel<ModelData>(); |
| modeleDeSelection.addListener(Events.SelectionChange, new SelectionChangedListener<ModelData>() { |
| public void selectionChanged(SelectionChangedEvent<ModelData> se) { |
| activerBoutonsOrdreAuteur(); |
| } |
| }); |
| |
| ColumnModel modeleDeColonnes = new ColumnModel(colonnes); |
| |
| // Grille |
| // ATTENTION : le constructure de cette grille est à vérifier! |
| final GrillePaginable<ModelData> grilleAuteurs = new GrillePaginable<ModelData>(modelTypePersonnesAPublication, virtualFields, proxyPersonnesAPublication, colonnes, modeleDeColonnes); |
| grilleAuteurs.getGrille().setHeight("100%"); |
| grilleAuteurs.getGrille().setBorders(true); |
| grilleAuteurs.getGrille().setSelectionModel(modeleDeSelection); |
| grilleAuteurs.getGrille().getView().setForceFit(true); |
| grilleAuteurs.getGrille().setAutoExpandColumn("fmt_nom_complet"); |
| grilleAuteurs.getGrille().setStripeRows(true); |
| grilleAuteurs.getGrille().setTrackMouseOver(true); |
| |
| grilleAuteurs.getStore().getLoader().addListener(Loader.Load, new Listener<LoadEvent>() { |
| public void handleEvent(LoadEvent be) { |
| List<ModelData> auteurs = grilleAuteurs.getStore().getModels(); |
| Iterator<ModelData> itAuteurs = auteurs.iterator(); |
| while (itAuteurs.hasNext()) { |
| ModelData selection = itAuteurs.next(); |
| PublicationAPersonne pap = new PublicationAPersonne(selection, aDonnee.GARDER_PREFIXE); |
| auteursInitialListe.put(pap.getId(), pap); |
| Log.debug("PublicationAPersonne ajoutée à la liste initiale avec l'id :"+pap.getId()+pap.toString()+selection.getProperties().toString()); |
| } |
| Log.debug("Initialisation liste auteur :"+auteursInitialListe.size()); |
| } |
| }); |
| |
| // Rajouter des écouteurs |
| grilleAuteurs.getStore().addListener(Store.Add, new Listener<StoreEvent<ModelData>>() { |
| public void handleEvent(StoreEvent<ModelData> ce) { |
| if (!changeOrderMarker) { |
| actualiserEtatBoutonsBarreOutils(); |
| } |
| } |
| }); |
| grilleAuteurs.getStore().addListener(Store.Remove, new Listener<StoreEvent<ModelData>>() { |
| public void handleEvent(StoreEvent<ModelData> ce) { |
| if (!changeOrderMarker) { |
| actualiserEtatBoutonsBarreOutils(); |
| Log.debug("Dans listener remove de grilleAuteur"); |
| } |
| } |
| }); |
| grilleAuteurs.getStore().addListener(Store.Update, new Listener<StoreEvent<ModelData>>() { |
| public void handleEvent(StoreEvent<ModelData> ce) { |
| |
| } |
| }); |
| |
| return grilleAuteurs; |
| } |
| |
| 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.getTitre(); |
| } |
| } |
| panneauFormulaire.setHeadingHtml(titre); |
| } |
| |
| |
| private void creerZoneAuteurs() { |
| auteursFieldset = new ContentPanel(); |
| auteursFieldset.setLayout(new FitLayout()); |
| auteursFieldset.setHeadingHtml("Auteurs"); |
| |
| creerChampsAuteur(); |
| } |
| |
| private void creerChampsAuteur() { |
| auteursFieldset.removeAll(); |
| barreOutils = creerBarreOutilsGrille(); |
| auteursFieldset.setTopComponent(barreOutils); |
| grilleAuteurs = creerGrilleAuteurs(); |
| auteursFieldset.add(grilleAuteurs); |
| auteursFieldset.layout(); |
| } |
| |
| private void creerZoneGeneralites() { |
| FormLayout layout = new FormLayout(); |
| layout.setLabelWidth(200); |
| |
| // Fieldset Infos Générales |
| generalitesFieldset = new FieldSet(); |
| generalitesFieldset.setHeadingHtml("Informations générales"); |
| generalitesFieldset.setCollapsible(true); |
| generalitesFieldset.setLayout(layout); |
| |
| 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.setHeadingHtml("É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>(null); |
| |
| 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(9); |
| datePublicationChp.setMinLength(4); |
| datePublicationChp.setFieldLabel("Année de publication"); |
| datePublicationChp.addStyleName(ComposantClass.OBLIGATOIRE); |
| datePublicationChp.addListener(Events.Valid, creerEcouteurChampObligatoire()); |
| editionFieldset.add(datePublicationChp, new FormData(80, 0)); |
| |
| /*********************************/ |
| /** Champ 'Tome' **/ |
| /*********************************/ |
| tomeChp = new TextField<String>(); |
| tomeChp.setFieldLabel("Série de la revue ou tome"); |
| editionFieldset.add(tomeChp, new FormData(75, 0)); |
| |
| /*************************************/ |
| /** Champ 'Fascicule' **/ |
| /*************************************/ |
| fasciculeChp = new TextField<String>(); |
| fasciculeChp.setFieldLabel("Fascicule de la revue"); |
| editionFieldset.add(fasciculeChp, new FormData(75, 0)); |
| |
| /*********************************/ |
| /** Champ 'Pages' **/ |
| /*********************************/ |
| 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)); |
| } |
| |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes privées |
| |
| private void miseAJourAuteursInitialListe() { |
| Iterator<String> clesAjoutees = auteursAjoutes.keySet().iterator(); |
| while (clesAjoutees.hasNext()) { |
| PublicationAPersonne auteurAjoute = auteursAjoutes.get(clesAjoutees.next()); |
| auteursInitialListe.put(auteurAjoute.getId(), auteurAjoute); |
| } |
| |
| Iterator<String> clesSupprimees = auteursSupprimes.keySet().iterator(); |
| while (clesSupprimees.hasNext()) { |
| PublicationAPersonne auteurSupprime = auteursSupprimes.get(clesSupprimees.next()); |
| auteursInitialListe.remove(auteurSupprime.getId()); |
| } |
| } |
| |
| public boolean soumettreFormulaire() { |
| boolean formulaireValideOk = verifierFormulaire(); |
| if (formulaireValideOk) { |
| soumettrePublication(); |
| } |
| |
| if(clicBoutonvalidation) { |
| fermerFormulaire(); |
| } |
| |
| return formulaireValideOk; |
| } |
| |
| private void soumettrePublication() { |
| Publication publicationCollectee = collecterPublication(); |
| if (publicationCollectee != null) { |
| // 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); |
| if (mode.equals(Formulaire.MODE_AJOUTER)) { |
| mediateur.ajouterPublication(sequenceur, publicationCollectee, seqId); |
| } else if (mode.equals(Formulaire.MODE_MODIFIER)) { |
| mediateur.modifierPublication(sequenceur, publicationCollectee, seqId); |
| } |
| |
| // 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(); |
| if(clicBoutonvalidation) { |
| fermerFormulaire(); |
| } |
| } |
| } |
| |
| private void soumettreAuteurs() { |
| //1) Auteurs ajoutés : |
| PublicationAPersonneListe listeAuteursAAjouter = new PublicationAPersonneListe(); |
| Iterator<String> itAuteur = auteursAjoutes.keySet().iterator(); |
| while (itAuteur.hasNext()) { |
| String cle = itAuteur.next(); |
| PublicationAPersonne publiAPersonne = auteursAjoutes.get(cle); |
| Log.debug("Ajouter :"+publiAPersonne.toString()); |
| publiAPersonne.setIdPublication(this.publicationId); |
| publiAPersonne.setOrdreAuteurs(publiAPersonne.getOrdreAuteurs()); |
| listeAuteursAAjouter.put(cle, publiAPersonne); |
| } |
| |
| // - envoyer au mediateur SSI personnes à ajouter |
| if (listeAuteursAAjouter.size() > 0) { |
| int seqId = sequenceur.lancerRequeteSynchrone(this); |
| mediateur.ajouterPublicationAPersonne(sequenceur, this.publicationId, listeAuteursAAjouter, PublicationAPersonne.ROLE_AUTEUR, seqId); |
| } |
| |
| //2) Auteurs supprimés : |
| PublicationAPersonneListe listeAuteursASupprimer = new PublicationAPersonneListe(); |
| itAuteur = auteursSupprimes.keySet().iterator(); |
| while (itAuteur.hasNext()) { |
| String cle = itAuteur.next(); |
| PublicationAPersonne publiAPersonne = auteursSupprimes.get(cle); |
| Log.debug("Supprimer :"+publiAPersonne.toString()); |
| listeAuteursASupprimer.put(cle, publiAPersonne); |
| } |
| |
| // - Envoyer au médiateur SSI personnes à supprimer |
| if (listeAuteursASupprimer.size() > 0) { |
| // Pour une suppression des auteurs, on a pas besoin d'attendre le retour |
| Log.debug("Lancement suppression :"+listeAuteursASupprimer.size()); |
| mediateur.supprimerPublicationAPersonne(this, listeAuteursASupprimer); |
| } |
| |
| //3) Auteurs modifiés : |
| PublicationAPersonneListe listeAuteursAModifier = new PublicationAPersonneListe(); |
| itAuteur = auteursModifies.keySet().iterator(); |
| while (itAuteur.hasNext()) { |
| String cle = itAuteur.next(); |
| PublicationAPersonne publiAPersonne = auteursModifies.get(cle); |
| Log.debug("Modifier :"+publiAPersonne.toString()); |
| listeAuteursAModifier.put(cle, publiAPersonne); |
| } |
| |
| // - Envoyer au médiateur SSI personnes à modifier |
| if (listeAuteursAModifier.size() > 0) { |
| int seqId = sequenceur.lancerRequeteSynchrone(this); |
| mediateur.modifierPublicationAPersonne(sequenceur, this.publicationId, listeAuteursAModifier, PublicationAPersonne.ROLE_AUTEUR, seqId); |
| } |
| |
| sequenceur.enfilerRafraichissement(this, new Information("auteurs_enregistres")); |
| } |
| |
| private void peuplerFormulaire() { |
| titreChp.setValue(publication.getTitre()); |
| collectionChp.setValue(publication.getCollection()); |
| uriChp.setValue(publication.getURI()); |
| datePublicationChp.setValue(publication.getAnneeParution()); |
| tomeChp.setValue(publication.getIndicationNvt()); |
| fasciculeChp.setValue(publication.getFascicule()); |
| pagesChp.setValue(publication.getPages()); |
| |
| // Éditeur est soit une référence à une structure de la base soit une chaine |
| if (publication.getEditeur().matches("^[0-9]+$")) { |
| //editeurCombobox.getCombo().setValue(editeurCombobox.getStore().findModel("cs_id_structure", publication.getEditeur())); |
| editeurCombobox.chargerValeurInitiale(publication.getEditeur(), "cs_id_structure"); |
| } else { |
| editeurCombobox.getCombo().setRawValue(publication.getEditeur()); |
| } |
| } |
| |
| private Publication collecterPublication() { |
| |
| Publication publicationCollectee = (Publication) publication.cloner(new Publication()); |
| 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(); |
| publicationCollectee.setAnneeParution(anneePublication); |
| |
| 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 construireDate(String valeurDate) { |
| |
| String dateComplete = ""; |
| if (!UtilString.isEmpty(valeurDate)){ |
| String jour = "00"; |
| String mois = "00"; |
| String annee = "0000"; |
| String messageErreur = null; |
| |
| /** JJ/MM/AAAA **/ |
| if (valeurDate.matches("\\d{2}/\\d{2}/\\d{4}")) { |
| |
| } |
| |
| /** MM/AAAA **/ |
| if (valeurDate.matches("\\d{2}/\\d{4}")) { |
| dateComplete = valeurDate+"-00"; |
| } |
| |
| /** AAAA **/ |
| if (valeurDate.matches("\\d{4}")) { |
| dateComplete = valeurDate+"-00-00"; |
| } |
| } |
| |
| return dateComplete; |
| } |
| |
| 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 = ""; |
| |
| // rangé par ordre désigné par le champ 'cpuap_ordre' de la table PublicationAPersonne |
| grilleAuteurs.getStore().sort("_ordre_", SortDir.ASC); |
| List<ModelData> auteurs = grilleAuteurs.getStore().getModels(); |
| Iterator<ModelData> itAuteurs = auteurs.iterator(); |
| |
| while (itAuteurs.hasNext()) { |
| Personne personneCourante = new PublicationAPersonne(itAuteurs.next(), false).getPersonne(); |
| intituleAuteur += personneCourante.getNom().toUpperCase() + " " + personneCourante.getPrenom(); |
| if (itAuteurs.hasNext()) { |
| intituleAuteur+=", "; |
| } |
| } |
| 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; |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // 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 (!Publication.etreAnneeParutionValide(datePublication)) { |
| messages.add("Le format de l'année saisie est incorrect ! Formats acceptés : AAAA ou AAAA-AAAA"); |
| } |
| } |
| |
| 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 |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Rafraichir |
| |
| public void rafraichir(Object nouvellesDonnees) { |
| if (nouvellesDonnees instanceof Publication) { |
| publication = (Publication) nouvellesDonnees; |
| } else if (nouvellesDonnees instanceof Information) { |
| rafraichirInformation((Information) nouvellesDonnees); |
| } else { |
| GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null); |
| } |
| } |
| |
| 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")) { |
| Debug.log("Chargement 1"); |
| peuplerFormulaire(); |
| genererTitreFormulaire(); |
| } |
| |
| if (type.equals("personne_ajoutee")) { |
| if (info.getDonnee(0) != null) { |
| Personne personne = (Personne) info.getDonnee(0); |
| personne = formaterChampPersonnePourGrille(personne); |
| PublicationAPersonne pap = new PublicationAPersonne(personne, false); |
| 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 = new PublicationAPersonne(grilleAuteurs.getStore().findModel("cp_id_personne", personne.getId()), false); |
| int index = grilleAuteurs.getStore().indexOf(personneDansGrille); |
| grilleAuteurs.getStore().remove(personneDansGrille); |
| if(index != -1) { |
| // ajouter la nouvelle entrée dans la grille |
| ajouterDansGrille(pap, index); |
| } else { |
| ajouterDansGrille(pap); |
| } |
| } |
| } 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; |
| this.publication.setId(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()); |
| } |
| } else if (info.getType().equals("suppression_publication_a_personne")) { |
| InfoLogger.display("Suppression d'auteur", info.getMessages().toString()); |
| } |
| } |
| |
| private Personne formaterChampPersonnePourGrille(Personne personne) { |
| personne.set("cp_id_personne", personne.getId()); |
| personne.set("cp_fmt_nom_complet", personne.getNomComplet()); |
| personne.set("cp_fmt_nom_complet", personne.getNomComplet()); |
| personne.set("cpuap_id_personne", personne.getId()); |
| personne.set("cp_code_postal", personne.get("code_postal")); |
| personne.set("cp_ville", personne.get("ville")); |
| personne.set("cp_truk_courriel", personne.getCourriel()); |
| |
| personne.set("cpuap_ordre", grilleAuteurs.getStore().getCount()); |
| personne.set("cp_nom", personne.getNom()); |
| personne.set("cp_prenom", personne.getPrenom()); |
| return personne; |
| } |
| |
| 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); |
| } |
| } |
| } |
| Property changes: |
|---|
| Added: svn:mergeinfo |
|---|
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/vues/publication/PublicationForm.java:r1136-1368 |
|---|
| Merged /trunk/src/org/tela_botanica/client/vues/publication/PublicationForm.java:r11-934,1209-1382 |
|---|
| Merged /branches/v1.1-aramon/src/org/tela_botanica/client/vues/publication/PublicationForm.java:r1383-1511 |
|---|
| Added: svn:executable |
|---|
| +* |
|---|
| \ No newline at end of property |
|---|