WebSVN – eFlore/Applications.coel – Diff – /trunk/src/org/tela_botanica/client/vues/publication/PublicationForm.java


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.Html;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.Label;
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;
import com.google.gwt.user.client.Window;
 
 
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;
	
	private Label infosAuteurFmt = null;
	private ContentPanel infosAuteursNonPresentsPanel = null;
	
	
	//+----------------------------------------------------------------------------------------------------------------+
	//    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();  
		
		creerComboBoxPersonnesSaisies();
		barreOutils.add(personnesSaisiesComboBox);
		
		personnesSaisiesComboBox.getCombo().setEmptyText("Rechercher et sélectionner une personne existante dans la base");
		
		barreOutils.add(new Text(" ou "));
		
		Button ajouterBouton = creerBoutonAjouter();
		barreOutils.add(ajouterBouton);
		
		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());
				}
				controlerCoherenceAuteurs();
				//zefgzf
				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);
		
		infosAuteursNonPresentsPanel = new ContentPanel();
		Label LabelAuteurFmt = new Label("Auteurs de la publication : ");
		LabelAuteurFmt.setId("label-auteurs-non-presents");
		infosAuteurFmt = new Label(publication.getAuteur());
		Label avertissementAuteurs = new Label("Attention, Certains auteurs apparaissent ci-dessous mais pas dans la grille des auteurs. "+
												"Ceci signifie que la publication a été importée sans que tous les auteurs aient été créés auparavant.<br />"+
												"Si vous souhaitez modifier cette publication, nous vous invitons à y associer correctement les auteurs grâce à la grille ci-dessus.<br />");
		
		infosAuteursNonPresentsPanel.setHeaderVisible(false);
		infosAuteursNonPresentsPanel.setId("infos-auteurs-non-presents");
		
		infosAuteursNonPresentsPanel.add(avertissementAuteurs);
		infosAuteursNonPresentsPanel.add(LabelAuteurFmt);
		infosAuteursNonPresentsPanel.add(infosAuteurFmt);
		infosAuteursNonPresentsPanel.setVisible(false);
		
		generalitesFieldset.add(infosAuteursNonPresentsPanel);
		
		
		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();
		}
		
		Publication.editeurs.put(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;
		}
		
		Publication.publisSaisiesModifieesCache.put(publicationId, publicationARetourner);
		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;
	}
	
	public void controlerCoherenceAuteurs() {
		if(doitAfficherAvertissementAuteur()) {
			infosAuteurFmt.setHtml(publication.getAuteur());
			infosAuteursNonPresentsPanel.setVisible(true);
			infosAuteursNonPresentsPanel.setHeight(50);
		} else {
			infosAuteursNonPresentsPanel.setVisible(false);
			infosAuteursNonPresentsPanel.setHeight(0);
		}
	}
	
	private boolean doitAfficherAvertissementAuteur() {
		// La construction du fmt nom complet des auteurs étant mal fichue
		// il est plus simple de comparer le nombre d'item une fois les chaines
		// splittées par virgules, ainsi que le nombre d'espace
		String auteurFmtreconstruit = construireIntituleAuteur();
		String[] auteurFmtreconstruitParts = auteurFmtreconstruit.split(",");
		String[] auteurParts = publication.getAuteur().split(",");
		
		String[] auteurFmtreconstruitSpaces = auteurFmtreconstruit.split(" ");
		String[] auteurPartsSpaces = publication.getAuteur().split(" ");
		
		boolean unEstVideEtAutreNon = (auteurFmtreconstruit.trim().isEmpty() != publication.getAuteur().isEmpty());
		
		return (modeDeCreation == MODE_MODIFIER && 
				(unEstVideEtAutreNon ||
				auteurFmtreconstruitParts.length != auteurParts.length ||
				auteurFmtreconstruitSpaces.length != auteurPartsSpaces.length));
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//    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);
		}
	}
}
Subversion Repositories eFlore/Applications.coel

(root)/trunk/src/org/tela_botanica/client/vues/publication/PublicationForm.java – Rev 1880 → 1896

Rev 1880		Rev 1896
1	`package org.tela_botanica.client.vues.publication;`	1	`package org.tela_botanica.client.vues.publication;`
2		2
3	`import java.util.ArrayList;`	3	`import java.util.ArrayList;`
4	`import java.util.HashMap;`	4	`import java.util.HashMap;`
5	`import java.util.Iterator;`	5	`import java.util.Iterator;`
6	`import java.util.List;`	6	`import java.util.List;`
7		7
8	`import org.tela_botanica.client.ComposantClass;`	8	`import org.tela_botanica.client.ComposantClass;`
9	`import org.tela_botanica.client.Mediateur;`	9	`import org.tela_botanica.client.Mediateur;`
10	`import org.tela_botanica.client.composants.ChampComboBoxRechercheTempsReelPaginable;`	10	`import org.tela_botanica.client.composants.ChampComboBoxRechercheTempsReelPaginable;`
11	`import org.tela_botanica.client.composants.GrillePaginable;`	11	`import org.tela_botanica.client.composants.GrillePaginable;`
12	`import org.tela_botanica.client.composants.InfoLogger;`	12	`import org.tela_botanica.client.composants.InfoLogger;`
13	`import org.tela_botanica.client.composants.pagination.ProxyPersonnes;`	13	`import org.tela_botanica.client.composants.pagination.ProxyPersonnes;`
14	`import org.tela_botanica.client.composants.pagination.ProxyPersonnesAPublication;`	14	`import org.tela_botanica.client.composants.pagination.ProxyPersonnesAPublication;`
15	`import org.tela_botanica.client.composants.pagination.ProxyStructures;`	15	`import org.tela_botanica.client.composants.pagination.ProxyStructures;`
16	`import org.tela_botanica.client.images.Images;`	16	`import org.tela_botanica.client.images.Images;`
17	`import org.tela_botanica.client.interfaces.Rafraichissable;`	17	`import org.tela_botanica.client.interfaces.Rafraichissable;`
18	`import org.tela_botanica.client.modeles.Information;`	18	`import org.tela_botanica.client.modeles.Information;`
19	`import org.tela_botanica.client.modeles.MenuApplicationId;`	19	`import org.tela_botanica.client.modeles.MenuApplicationId;`
20	`import org.tela_botanica.client.modeles.aDonnee;`	20	`import org.tela_botanica.client.modeles.aDonnee;`
21	`import org.tela_botanica.client.modeles.personne.Personne;`	21	`import org.tela_botanica.client.modeles.personne.Personne;`
22	`import org.tela_botanica.client.modeles.publication.Publication;`	22	`import org.tela_botanica.client.modeles.publication.Publication;`
23	`import org.tela_botanica.client.modeles.publication.PublicationAPersonne;`	23	`import org.tela_botanica.client.modeles.publication.PublicationAPersonne;`
24	`import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe;`	24	`import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe;`
25	`import org.tela_botanica.client.modeles.structure.Structure;`	25	`import org.tela_botanica.client.modeles.structure.Structure;`
26	`import org.tela_botanica.client.synchronisation.Sequenceur;`	26	`import org.tela_botanica.client.synchronisation.Sequenceur;`
27	`import org.tela_botanica.client.util.Debug;`	27	`import org.tela_botanica.client.util.Debug;`
28	`import org.tela_botanica.client.util.Log;`	28	`import org.tela_botanica.client.util.Log;`
29	`import org.tela_botanica.client.util.Pattern;`	29	`import org.tela_botanica.client.util.Pattern;`
30	`import org.tela_botanica.client.util.UtilArray;`	30	`import org.tela_botanica.client.util.UtilArray;`
31	`import org.tela_botanica.client.util.UtilString;`	31	`import org.tela_botanica.client.util.UtilString;`
32	`import org.tela_botanica.client.vues.FenetreForm;`	32	`import org.tela_botanica.client.vues.FenetreForm;`
33	`import org.tela_botanica.client.vues.Formulaire;`	33	`import org.tela_botanica.client.vues.Formulaire;`
34	`import org.tela_botanica.client.vues.FormulaireBarreValidation;`	34	`import org.tela_botanica.client.vues.FormulaireBarreValidation;`
35	`import org.tela_botanica.client.vues.personne.PersonneForm;`	35	`import org.tela_botanica.client.vues.personne.PersonneForm;`
36		36
37	`import com.extjs.gxt.ui.client.Style.Scroll;`	37	`import com.extjs.gxt.ui.client.Style.Scroll;`
38	`import com.extjs.gxt.ui.client.Style.SortDir;`	38	`import com.extjs.gxt.ui.client.Style.SortDir;`
39	`import com.extjs.gxt.ui.client.data.BaseModelData;`	39	`import com.extjs.gxt.ui.client.data.BaseModelData;`
40	`import com.extjs.gxt.ui.client.data.LoadEvent;`	40	`import com.extjs.gxt.ui.client.data.LoadEvent;`