Subversion Repositories eFlore/Applications.coel

package org.tela_botanica.client.vues.publication;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.tela_botanica.client.Mediateur;
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.personne.Personne;
import org.tela_botanica.client.modeles.personne.PersonneListe;
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.Pattern;
import org.tela_botanica.client.util.UtilArray;
import org.tela_botanica.client.util.UtilString;
import org.tela_botanica.client.vues.Formulaire;

import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.HorizontalPanel;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
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.google.gwt.core.client.GWT;


public class PublicationForm extends Formulaire implements Rafraichissable {
        
        private Publication publication;
        private PublicationAPersonneListe publicationAPersonneListe = null;
        private static boolean publicationAPersonneListeChargementOk = false;
        private PublicationAPersonneListe auteursAjoutes = null;
        private PublicationAPersonneListe auteursSupprimes = null;
        
        private FieldSet auteursFieldset = null;
        private ArrayList<ComboBox<Personne>> auteurComboboxListe = null;
        private LayoutContainer conteneurChamps;
        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 ComboBox<Structure> editeurCombobox = null;
        private TextField<String> datePublicationChp = null;
        private TextField<String> tomeChp = null;
        private TextField<String> fasciculeChp = null;
        private TextField<String> pagesChp = null;
        
        private String idStructureEdition = ""; 

        private static boolean formulaireValideOk = false;
        private static boolean publicationValideOk = false;
        private static boolean auteursValideOk = false;
        private static boolean attenteAjoutAuteursOk = true;
        private static boolean attenteSuppressionAuteursOk = true;

        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) {
                publicationAPersonneListe = new PublicationAPersonneListe();
                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 FlowLayout());
                String titre = genererTitreFormulaire();
                panneauFormulaire.setHeading(titre);

                creerZoneAuteurs();
                panneauFormulaire.add(auteursFieldset);
                
                creerZoneGeneralites();
                panneauFormulaire.add(generalitesFieldset);
                
                creerZoneEdition();
                panneauFormulaire.add(editionFieldset);
                
                if (modeDeCreation.equals(Formulaire.MODE_MODIFIER)) {
                        mediateurCourrant.selectionnerPublication(this, publicationId);
                        mediateurCourrant.selectionnerPublicationAPersonne(this, publicationId, null, PublicationAPersonne.ROLE_AUTEUR);
                }
        }
        
        private String genererTitreFormulaire() {
                String titre = "Ajout d'une publication";
                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                         titre = "Modification d'une publication - "+i18nC.id()+": "+publication.getId();
                }
                return titre;
        }
        
        private void creerZoneAuteurs() {
                FormLayout layout = new FormLayout();
                layout.setLabelWidth(200);
                
                // Fieldset Auteur
                auteursFieldset = new FieldSet();
                auteursFieldset.setHeading("Auteur(s)");
                auteursFieldset.setCollapsible(true);
                auteursFieldset.setLayout(layout);
                
                auteurComboboxListe = new ArrayList<ComboBox<Personne>>(0);
                auteursStorePartage = new ListStore<Personne>();
                mediateur.clicObtenirListeAuteurs(this);
                
                creerChampsAuteur();
        }
        
        private void creerChampsAuteur() {
                auteursFieldset.removeAll();
                
                conteneurChamps = new LayoutContainer(); 
                                
                Button ajouterAuteurBouton = new Button("Ajouter un auteur");
                ajouterAuteurBouton.setIcon(Images.ICONES.ajouter());
                ajouterAuteurBouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
                        @Override
                        public void componentSelected(ButtonEvent be) {
                                creerChampAuteurEtBoutonSupprimer(null);
                        }
                });
                
                auteursFieldset.add(conteneurChamps);
                auteursFieldset.add(ajouterAuteurBouton);
                auteursFieldset.layout(true);
                
                if (mode.equals(Formulaire.MODE_AJOUTER)) {
                        creerChampAuteurEtBoutonSupprimer(null);
                }
        }
        
        public void creerChampAuteurEtBoutonSupprimer(Personne auteur) {
                final HorizontalPanel panneauHorizontal = new HorizontalPanel();
                panneauHorizontal.setLayout(new FormLayout());
                
                final ComboBox<Personne> auteursSaisisComboBox = creerComboBoxAuteursSaisis();
                if (auteur != null) {
                        GWT.log("Auteur peuplé : "+auteur.getId(), null);
                        auteursSaisisComboBox.setValue(auteursStorePartage.findModel("id_personne", auteur.getId()));
                        auteursSaisisComboBox.validate();
                }
                auteurComboboxListe.add(auteursSaisisComboBox);
                auteursSaisisComboBox.setFieldLabel("Auteur "+auteurComboboxListe.size());
                GWT.log("Nbre de combobox auteur dans liste : "+auteurComboboxListe.size(), null);
                
                LayoutContainer panneauChampTxtEtBouton = new LayoutContainer();
                panneauChampTxtEtBouton.setLayout(new FormLayout());
                panneauChampTxtEtBouton.add(auteursSaisisComboBox, new FormData(300, 0));
                panneauHorizontal.add(panneauChampTxtEtBouton);
                
                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("Auteur "+numeroAuteurs);
                                        numeroAuteurs++;
                                }

                                auteursFieldset.layout(true);
                        }
                });
                panneauHorizontal.add(supprimerAuteurBouton);
                
                conteneurChamps.add(panneauHorizontal);
                auteursFieldset.layout(true);
        }
        
        private ComboBox<Personne> creerComboBoxAuteursSaisis() {
                ComboBox<Personne> comboBox = new ComboBox<Personne>();
                comboBox.setEmptyText(i18nC.chercherPersonneSaisi());
                comboBox.setEditable(true);
                comboBox.setForceSelection(true);
                comboBox.setDisplayField("fmt_nom_complet");
                comboBox.setTriggerAction(TriggerAction.ALL);
                comboBox.setStore(auteursStorePartage);
                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);
                
                titreChp = new TextField<String>();
                titreChp.setName("cpu");
                titreChp.setFieldLabel("Titre de l'article ou de l'ouvrage");
                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);
                
                ListStore<Structure> editeurStore = new ListStore<Structure>();
                editeurCombobox = new ComboBox<Structure>();  
                editeurCombobox.setEmptyText("Sélectionner un éditeur...");
                editeurCombobox.setFieldLabel("Éditeur de la publication");
                editeurCombobox.setDisplayField("nom");
                editeurCombobox.setStore(editeurStore);
                editeurCombobox.setEditable(true);
                editeurCombobox.setTriggerAction(TriggerAction.ALL);
                editionFieldset.add(editeurCombobox, new FormData(450, 0));
                mediateur.clicObtenirListeEditeurs(this);
                
                datePublicationChp = new TextField<String>();
                datePublicationChp.setMaxLength(4);
                datePublicationChp.setMinLength(4);
                datePublicationChp.setFieldLabel("Année de publication");
                datePublicationChp.addListener(Events.Valid, creerEcouteurChampObligatoire());
                editionFieldset.add(datePublicationChp, new FormData(40, 0));
                
                tomeChp = new TextField<String>();
                tomeChp.setFieldLabel("Série de la revue ou tome");
                editionFieldset.add(tomeChp, new FormData(75, 0));
                
                fasciculeChp = new TextField<String>();
                fasciculeChp.setFieldLabel("Fascicule de la revue");
                editionFieldset.add(fasciculeChp, new FormData(75, 0));
                
                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 StructureListe) {
                        // Si on a reçu une liste des editeurs
                        rafraichirListeEditeurs((StructureListe) 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);
                }
                
                if (etrePretAAfficherAuteurs()) {
                        initialiserAffichageAuteurs();
                        afficherAuteurs();
                }
                
                if (etreValide()) {
                        initialiserValidation();
                        repandreRafraichissement();
                        controlerFermetureApresRafraichissement();
                }
        }
        
        private void miseAJourPublicationAPersonneListe() {
                GWT.log("Mise à jour liste publication à personne", null);
                Iterator<String> clesAjoutees = auteursAjoutes.keySet().iterator();
                while (clesAjoutees.hasNext()) {
                        String id = clesAjoutees.next();
                        publicationAPersonneListe.put(id, auteursAjoutes.get(id));
                        GWT.log("Auteurs ajouté :"+publicationAPersonneListe.get(id).getPersonne().getNomComplet(), null);
                }
                
                Iterator<String> clesSupprimees = auteursSupprimes.keySet().iterator();
                while (clesSupprimees.hasNext()) {
                        String id = clesSupprimees.next();
                        publicationAPersonneListe.remove(id);
                        GWT.log("Personne surpprimé :"+id, null);
                }
                GWT.log("Nbre auteurs après maj :"+publicationAPersonneListe.size(), null);
        }
        
        private void rafraichirPublication(Publication publi) {
                publication = publi;
                peuplerFormulaire();
        }
        
        private void rafraichirListeEditeurs(StructureListe editeurs) {
                editeurCombobox.getStore().removeAll();
                editeurCombobox.getStore().add((List<Structure>) editeurs.toList());
                
                if (mode.equals(Formulaire.MODE_MODIFIER)) {    
                        editeurCombobox.setValue((Structure) editeurs.get(idStructureEdition));
                }
                editeurCombobox.expand();
        }
        
        private void rafraichirListeAuteurs(PublicationAPersonneListe auteurs) {
                publicationAPersonneListe = auteurs;
                publicationAPersonneListeChargementOk = true;
        }
        
        private void rafraichirInformation(Information info) {
                if (info.getType().equals("liste_personne")) {
                        PersonneListe listePersonneAuteur = (PersonneListe) info.getDonnee(0);
                        
                        List<Personne> liste = listePersonneAuteur.toList();
                        auteursStorePartage.removeAll();
                        auteursStorePartage.add(liste);
                        
                        auteurStorePartageChargementOk = true;
                } else if (info.getType().equals("publication_valide")) {
                        publicationValideOk = true;
                        publication.setId((String) info.getDonnee(0));
                        
                        if (mode.equals(Formulaire.MODE_AJOUTER)) {
                                attenteAjoutAuteursOk = true;
                                mediateur.ajouterPublicationAPersonne(this, publication.getId(), auteursAjoutes, PublicationAPersonne.ROLE_AUTEUR);
                        }
                } else if (info.getType().equals("ajout_publication_a_personne")) {
                        attenteAjoutAuteursOk = false;
                        GWT.log("attenteAjoutAuteursOk", null);
                } else if (info.getType().equals("suppression_publication_a_personne")) {
                        attenteSuppressionAuteursOk = false;
                        GWT.log("attenteSuppressionAuteursOk", null);
                }
                
                if (avoirAuteursMiseAJourCorrectement()) {
                        auteursValideOk = true;
                        miseAJourPublicationAPersonneListe();
                        initialiserAuteurs();
                }
        }
        
        private boolean avoirAuteursMiseAJourCorrectement() {
                boolean ok = false;
                if (attenteAjoutAuteursOk == false && attenteSuppressionAuteursOk == false) {
                        ok = true;
                }
                return ok;
        }
        
        private void afficherAuteurs() {
                Iterator<String> itap = publicationAPersonneListe.keySet().iterator();
                GWT.log("Auteur"+publicationAPersonneListe.size(), null);
                while (itap.hasNext()) {
                        creerChampAuteurEtBoutonSupprimer(publicationAPersonneListe.get(itap.next()).getPersonne());
                }
        }

        private void initialiserAffichageAuteurs() {
                auteurStorePartageChargementOk = false;
                publicationAPersonneListeChargementOk = false;
        }

        private boolean etrePretAAfficherAuteurs() {
                boolean ok = false;
                if (auteurStorePartageChargementOk && publicationAPersonneListeChargementOk) {
                        ok = true;
                }
                return ok;
        }

        private Boolean etreValide() {
                Boolean valide = false;
                GWT.log("formulaire"+formulaireValideOk+" - Publication :"+publicationValideOk+" - Auteurs :"+auteursValideOk, null);
                if (formulaireValideOk && publicationValideOk && auteursValideOk) {
                        valide = true;
                }
                return valide;
        }
        
        private void initialiserValidation() {
                formulaireValideOk = false;
                publicationValideOk = false;
                initialiserAuteurs();
                auteursValideOk = false;
        }
        
        private void initialiserAuteurs() {
                attenteAjoutAuteursOk = true;
                auteursAjoutes = new PublicationAPersonneListe();
                attenteSuppressionAuteursOk = true;
                auteursSupprimes = new PublicationAPersonneListe();
        }
        
        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();
                GWT.log("Form?"+formulaireValideOk, null);
                if (formulaireValideOk) {
                        soumettrePublication();
                        soumettreAuteurs();
                }
                return formulaireValideOk;
        }
        
        private void soumettrePublication() {
                Publication publicationCollectee = collecterPublication();
                if (publicationCollectee != null) {
                        GWT.log("Info public collectée ? ok", 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;
                
                PersonneListe personnesInitiales = new PersonneListe();
                if (publicationAPersonneListe != null) {
                        GWT.log("Nbre auteur initial :"+publicationAPersonneListe.size(), null);
                        Iterator<String> itap = publicationAPersonneListe.keySet().iterator();
                        while (itap.hasNext()) {
                                Personne personne = publicationAPersonneListe.get(itap.next()).getPersonne();
                                GWT.log("Auteur initial :"+personne.getNomComplet(), null);
                                personnesInitiales.put(personne.getId(), personne);
                        }
                }
                
                PersonneListe personnesActuelles = new PersonneListe();
                GWT.log("Nbre auteur actuel :"+auteurComboboxListe.size(), null);
                for (int i = 0; i < auteurComboboxListe.size(); i++) {
                        if (auteurComboboxListe.get(i).getValue() != null) {
                                Personne personne = auteurComboboxListe.get(i).getValue();
                                personnesActuelles.put(personne.getId(), personne);
                        }
                }
                
                // 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);
                                GWT.log("Auteur ajouté :"+personne.getNomComplet(), null);
                                PublicationAPersonne publicationAAuteur = new PublicationAPersonne();
                                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                                        publicationAAuteur.setIdPublication(publication.getId());
                                }
                                publicationAAuteur.setPersonne(personne);
                                publicationAAuteur.setIdRole(PublicationAPersonne.ROLE_AUTEUR);
                                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);
                                        GWT.log("Auteur supprimé :"+personne.getNomComplet(), null);
                                        PublicationAPersonne publicationAAuteur = new PublicationAPersonne();
                                        publicationAAuteur.setIdPublication(publication.getId());
                                        publicationAAuteur.setPersonne(personne);
                                        publicationAAuteur.setIdRole(PublicationAPersonne.ROLE_AUTEUR);
                                        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) {
                                mediateur.ajouterPublicationAPersonne(this, publication.getId(), auteursAjoutes, PublicationAPersonne.ROLE_AUTEUR);
                        }
                        
                        if (auteursSupprimes != null && auteursSupprimes.size() != 0) {
                                mediateur.supprimerPublicationAPersonne(this, auteursSupprimes);
                        }
                }
        }
        
        public boolean verifierFormulaire() {
                boolean valide = true;
                ArrayList<String> messages = new ArrayList<String>();
                
                boolean auteurErreur = true;
                for (int i = 0; i < auteurComboboxListe.size(); i++) {
                        if (auteurComboboxListe.get(i).getValue() != null) {
                                auteurErreur = false;
                                break;
                        }
                }
                if (auteurErreur) {
                        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() {
                creerChampsAuteur();
                titreChp.setValue(publication.getTitre());
                collectionChp.setValue(publication.getCollection());
                uriChp.setValue(publication.getURI());
                datePublicationChp.setRawValue(reduireDateParAnnee(publication.getDateParution()));
                tomeChp.setValue(publication.getIndicationNvt());
                fasciculeChp.setValue(publication.getFascicule());
                pagesChp.setValue(publication.getPages());
                
                if (publication.getEditeur().matches("^[0-9]+$")) {
                        editeurCombobox.setValue(editeurCombobox.getStore().findModel("id_structure", publication.getEditeur()));
                        idStructureEdition = publication.getEditeur();
                } else {
                        editeurCombobox.setRawValue(publication.getEditeur());
                }
        }
        
        private Publication collecterPublication() {
                Publication publicationCollectee = (Publication) publication.cloner(new Publication());
                
                String auteurIntituleFormate = "";
                int auteursNombre = auteurComboboxListe.size();
                for (int i = 0; i < auteursNombre; i++) {
                        if (auteurComboboxListe.get(i).getValue() != null) {
                                Personne auteur = auteurComboboxListe.get(i).getValue();
                                auteurIntituleFormate += auteur.getNom()+ " "+auteur.getPrenom();
                                if (i != (auteursNombre - 1)) {
                                        auteurIntituleFormate += ", ";
                                }
                        }
                }
                GWT.log("Auteurs formaté :"+auteurIntituleFormate, null);
                publicationCollectee.setAuteur(auteurIntituleFormate);
                
                String titre = titreChp.getValue();
                publicationCollectee.setTitre(titre);
                
                String collection = collectionChp.getValue();
                publicationCollectee.setCollection(collection);
                
                String nomComplet = titreChp.getValue()+" "+collectionChp.getValue();
                publicationCollectee.setNomComplet(nomComplet);
                
                String uri = uriChp.getValue();
                publicationCollectee.setUri(uri);
                
                String editeur = "";
                if (editeurCombobox.getValue() != null) {
                        editeur = editeurCombobox.getValue().getId();
                        publicationCollectee.setStructureEditeur(editeurCombobox.getValue());
                } else if (editeurCombobox.getRawValue() != "") {
                        editeur = editeurCombobox.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;
        }
        
        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 "";
                }
        }
}