WebSVN – eFlore/Applications.coel – Diff – /trunk/src/org/tela_botanica/client/vues/collection/CollectionFormPersonne.java


package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
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.ProxyCollectionAPersonne;
import org.tela_botanica.client.composants.pagination.ProxyPersonnes;
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.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.modeles.collection.Collection;
import org.tela_botanica.client.modeles.collection.CollectionAPersonne;
import org.tela_botanica.client.modeles.collection.CollectionAPersonneListe;
import org.tela_botanica.client.modeles.personne.Personne;
import org.tela_botanica.client.synchronisation.Sequenceur;
import org.tela_botanica.client.util.Debug;
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.FormulaireOnglet;
import org.tela_botanica.client.vues.personne.PersonneForm;
 
import com.extjs.gxt.ui.client.Style.Scroll;
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.FieldEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.Store;
import com.extjs.gxt.ui.client.store.StoreEvent;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.button.ButtonBar;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.Field;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.Validator;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnData;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.GridCellRenderer;
import com.extjs.gxt.ui.client.widget.grid.HeaderGroupConfig;
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
 
public class CollectionFormPersonne extends FormulaireOnglet implements Rafraichissable {
	
	public static final String ID = "personne";
	private Collection collection = null;
	private static int idGenere = 1;
	
	private ContentPanel panneauPrincipal = null;
	private ToolBar barreOutils = null;
	private GrillePaginable<ModelData> grille;
	
	private ComboBox<Valeur> typeRelationCombo = null;
	
	private CollectionAPersonneListe personnesAjoutees = null;
	private CollectionAPersonneListe personnesSupprimees = null;
	private ChampComboBoxRechercheTempsReelPaginable personnesSaisisComboBox = null;
	private ChampComboBoxRechercheTempsReelPaginable recherchePersonnesCombo = null;
	private Button personnesBoutonSupprimer = null;
	private Button personnesBoutonModifier = null;
	private ListStore<Valeur> listeIon = null;
	
	private FenetreForm fenetreFormulaire = null;
	
	private Sequenceur sequenceur = new Sequenceur();
	
	public CollectionFormPersonne(Formulaire formulaireCourrant) {
		
		initialiserOnglet(formulaireCourrant);
		setLayout(new FitLayout());
		setScrollMode(Scroll.AUTO);
		setId(ID);
		setText(Mediateur.i18nC.collectionPersonne());
		setStyleAttribute("padding", "0");
		
		initialiser();
		
		panneauPrincipal = creerPanneauContenantGrille();
		barreOutils = creerBarreOutilsGrille();
		panneauPrincipal.setTopComponent(barreOutils);
		grille = creerGrille();
  		panneauPrincipal.add(grille);
  		
  		mediateur.obtenirListeValeurEtRafraichir(this, "ion", sequenceur);
		mediateur.obtenirListeValeurEtRafraichir(this, "relationPersonneCollection", sequenceur);
		add(panneauPrincipal);
	}
	
	private void initialiser() {
		// Remise à zéro des modification dans la liste des auteurs
		idGenere = 1;
		personnesAjoutees = new CollectionAPersonneListe();
		personnesSupprimees = new CollectionAPersonneListe();
		
		collection = ((CollectionForm) formulaire).collection;
	}
	
	private ContentPanel creerPanneauContenantGrille() {
		ContentPanel panneau = new ContentPanel();
		
		panneau.setHeading(i18nC.collectionPersonneTitre());
		panneau.setIcon(Images.ICONES.table());
		panneau.setLayout(new FitLayout());
		
		panneau.setFrame(true);
		panneau.setScrollMode(Scroll.AUTO);
		
		return panneau;
	}
 
	private ToolBar creerBarreOutilsGrille() {
		ToolBar barreOutils = new ToolBar();  
		
		Button ajouterPersonneBouton = creerBoutonAjouter();
		barreOutils.add(ajouterPersonneBouton);
		
		barreOutils.add(new Text(" ou "));
		
		personnesSaisisComboBox = creerComboBoxPersonnesSaisies();
		barreOutils.add(personnesSaisisComboBox);
		
		barreOutils.add(new SeparatorToolItem());
		
		personnesBoutonModifier = creerBoutonModifier();
		barreOutils.add(personnesBoutonModifier);
		
		barreOutils.add(new SeparatorToolItem());
		
		personnesBoutonSupprimer = creerBoutonSupprimer();
		barreOutils.add(personnesBoutonSupprimer);		
		
		barreOutils.add(new SeparatorToolItem());
		
		Button rafraichirPersonneBouton = creerBoutonRafraichir();
		barreOutils.add(rafraichirPersonneBouton);
				
		return barreOutils;
	}
 
	private Button creerBoutonAjouter() {
		Button bouton = new Button(i18nC.ajouter());
		bouton.setIcon(Images.ICONES.vcardAjouter());
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
 
			public void componentSelected(ButtonEvent ce) {  
				fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_AJOUTER);
				fenetreFormulaire.show();
			}  
		});
		return bouton;
	}
	
	private Button creerBoutonModifier() {
		Button bouton = new Button(i18nC.modifier());
		bouton.setIcon(Images.ICONES.vcardModifier());
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
			public void componentSelected(ButtonEvent ce) {				
				CollectionAPersonne personneSaisiSelectionne = new CollectionAPersonne(grille.getSelection());
				
				if (personneSaisiSelectionne == null) {
					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPersonne());
				} else {
					fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_MODIFIER);
					fenetreFormulaire.show();
				}
			}  
		});
		return bouton;
	}
	
	private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
		String personneId = null;
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
			CollectionAPersonne personneSaisieSelectionnee = new CollectionAPersonne(grille.getSelection());
			personneId = personneSaisieSelectionnee.getIdPersonne();
		}
		
		final FenetreForm fenetre = new FenetreForm("");
		final PersonneForm formulaire = creerFormulairePersonne(fenetre, personneId);
		fenetre.add(formulaire);
		return fenetre;
	}
	
	private PersonneForm creerFormulairePersonne(final FenetreForm fenetre, String personneId) {
		PersonneForm formulaire = new PersonneForm(mediateur, personneId, this);
		FormPanel panneauFormulaire = formulaire.getFormulaire();
		fenetre.setHeading(panneauFormulaire.getHeading());
		panneauFormulaire.setHeaderVisible(false);
		panneauFormulaire.setTopComponent(null);
 
		// FIXME : avec GXT-2.1.0 la redéfinition du bottom component ne marche plus. Nous le cachons et en créeons un dans la fenêtre.
		panneauFormulaire.getBottomComponent().hide();
		SelectionListener<ButtonEvent> ecouteur = creerEcouteurValidationFormulairePersonne(fenetre, formulaire);
		final ButtonBar barreValidation = new FormulaireBarreValidation(ecouteur);
		fenetre.setBottomComponent(barreValidation);
		
		return formulaire;
	}
	
	private SelectionListener<ButtonEvent> creerEcouteurValidationFormulairePersonne(final FenetreForm fenetre, final PersonneForm formulaire) {
		SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
			public void componentSelected(ButtonEvent ce) {
				String code = ((Button) ce.getComponent()).getData("code");
				if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
					if (formulaire.soumettreFormulaire()) {
						fenetre.hide();
					}
				} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
					formulaire.soumettreFormulaire();
				} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
					fenetre.hide();
				} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
					fenetreFormulaire.hide();
					fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(formulaire.mode);
					fenetreFormulaire.show();
				}
			}
		};
		
		return ecouteur;
	}
	
	private Button creerBoutonSupprimer() {
		Button bouton = new Button(i18nC.supprimer());
		bouton.setIcon(Images.ICONES.vcardSupprimer());
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
			public void componentSelected(ButtonEvent ce) {
				ModelData personneSaisiSelectionnee = grille.getSelection();
				if (personneSaisiSelectionnee == null) {
					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPersonne());
				} else {
					supprimerDansGrille(personneSaisiSelectionnee);
				}
			}   
		});
		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 ChampComboBoxRechercheTempsReelPaginable creerComboBoxPersonnesSaisies() {
	
		ModelType modelTypePersonnes = new ModelType();
		modelTypePersonnes.setRoot("personnes");
		modelTypePersonnes.setTotalName("nbElements");
		modelTypePersonnes.addField("cp_fmt_nom_complet");
		modelTypePersonnes.addField("cp_id_personne");
		modelTypePersonnes.addField("cp_nom");
		modelTypePersonnes.addField("cp_prenom");
		modelTypePersonnes.addField("cp_code_postal");
		modelTypePersonnes.addField("cp_naissance_date");
		modelTypePersonnes.addField("cp_naissance_lieu");
		modelTypePersonnes.addField("cp_ce_deces");
		modelTypePersonnes.addField("cp_deces_date");
		modelTypePersonnes.addField("cp_deces_lieu");
		
		String displayNamePersonnes = "cp_fmt_nom_complet";
		ProxyPersonnes<ModelData> proxyPersonnes = new ProxyPersonnes<ModelData>(null);
		
		recherchePersonnesCombo = new ChampComboBoxRechercheTempsReelPaginable(proxyPersonnes, modelTypePersonnes, displayNamePersonnes);
		recherchePersonnesCombo.getCombo().setForceSelection(true);
		
		recherchePersonnesCombo.getCombo().setValidator(new Validator() {
			public String validate(Field<?> field, String value) {
				String retour = null;
				if (field.getRawValue().equals("")) {
					field.setValue(null);
				} else if (recherchePersonnesCombo.getStore().findModel("cp_fmt_nom_complet", field.getRawValue()) == null) {
					String contenuBrut = field.getRawValue();
					field.setValue(null);
					field.setRawValue(contenuBrut);
					retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
				}
				return retour;
			}
		});
		
		recherchePersonnesCombo.getCombo().addListener(Events.Select, new Listener<BaseEvent>() {
			public void handleEvent(BaseEvent be) {
				if (personnesSaisisComboBox.getValeur() instanceof ModelData) {					
					Personne personneSaisiSelectionnee = new Personne(personnesSaisisComboBox.getValeur());
					ajouterDansGrille(personneSaisiSelectionnee);
					personnesSaisisComboBox.getCombo().setValue(null);
				}
			}
		});
 
		return recherchePersonnesCombo;
	}
	
	private void ajouterDansGrille(Personne personne) {
		ajouterDansGrille(personne, null, 0);
	}
	
	private void ajouterDansGrille(Personne personne, String relation, int index) {
		if (personne != null) {
			CollectionAPersonne relationCollectionPersonne = new CollectionAPersonne();
			relationCollectionPersonne.setPersonnePourGrillePaginable(personne);
			relationCollectionPersonne.setIdPersonne(personne.getId());
			
			if (relation != null) {
				relationCollectionPersonne.set("_role_", relation);
			}
			// Gestion de l'id de la collection
			if (mode.equals(Formulaire.MODE_MODIFIER)) {
				relationCollectionPersonne.setIdCollection(collection.getId());
			}
			
			relationCollectionPersonne.set("_etat_", aDonnee.ETAT_AJOUTE);
			
			// FIXME  besoin de ça ?
			//corrigerChampsGrille(relationCollectionPersonne);
			
			// Ajout à la grille
			grille.getGrille().stopEditing();
			grille.getGrille().getStore().insert(relationCollectionPersonne, index);
			grille.getGrille().startEditing(index, 0);
			grille.getGrille().getSelectionModel().select(index, false);
		}
	}
	
	private void supprimerDansGrille(ModelData relationCollectionPersonne) {
		
		CollectionAPersonne cap = new CollectionAPersonne(relationCollectionPersonne);
		
		if (relationCollectionPersonne != null) {
			// Ajout de la personne supprimée à la liste
			if ((relationCollectionPersonne.get("_etat_") == null
					|| relationCollectionPersonne.get("_etat_").equals("")
					|| !relationCollectionPersonne.get("_etat_").equals(aDonnee.ETAT_AJOUTE)) 
					&& cap.getId() != null 
					&& !cap.getId().equals("")) {
				
				personnesSupprimees.put("id"+idGenere++, cap);
			}
			grille.getStore().remove(relationCollectionPersonne);
		}
	}
 
	private GrillePaginable<ModelData> creerGrille() {
		
		// ModelType
		ModelType modelTypeCollectionAPersonne = new ModelType();
		modelTypeCollectionAPersonne.setRoot("collectionsAPersonne");
		modelTypeCollectionAPersonne.setTotalName("nbElements");
		modelTypeCollectionAPersonne.addField("cp_fmt_nom_complet");
		modelTypeCollectionAPersonne.addField("cp_nom");
		modelTypeCollectionAPersonne.addField("cp_prenom");
		modelTypeCollectionAPersonne.addField("cp_code_postal");
		modelTypeCollectionAPersonne.addField("cp_naissance_date");
		modelTypeCollectionAPersonne.addField("cp_naissance_lieu");
		modelTypeCollectionAPersonne.addField("cp_ce_deces");
		modelTypeCollectionAPersonne.addField("cp_deces_date");
		modelTypeCollectionAPersonne.addField("cp_deces_lieu");
		modelTypeCollectionAPersonne.addField("ccap_id_collection");
		modelTypeCollectionAPersonne.addField("ccap_id_personne");
		modelTypeCollectionAPersonne.addField("ccap_id_role");
		
		// Proxy
		ProxyCollectionAPersonne<ModelData> proxyCollectionAPersonne = new ProxyCollectionAPersonne<ModelData>(null, collection.getId(), null);		
 
		// Colonnes
		List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
		colonnes.add(new RowNumberer());
		colonnes.add(creerColonneRole());
		colonnes.add(new ColumnConfig("cp_fmt_nom_complet", i18nC.personneNomComplet(), 150));
		colonnes.add(new ColumnConfig("cp_nom", i18nC.personneNom(), 75));
		colonnes.add(new ColumnConfig("cp_prenom", i18nC.personnePrenom(), 75));
		colonnes.add(new ColumnConfig("cp_naissance_date", i18nC.date(), 75));
		colonnes.add(new ColumnConfig("cp_naissance_lieu", i18nC.lieu(), 100));
		colonnes.add(creerColonneDeces());
		colonnes.add(new ColumnConfig("cp_deces_date", i18nC.date(), 75));
		colonnes.add(new ColumnConfig("cp_deces_lieu", i18nC.lieu(), 100));
		
		// Modèle de colonnes
		ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
		modeleDeColonnes.addHeaderGroup(0, 1, new HeaderGroupConfig(i18nC.personneIdentite(), 1, 4));
		modeleDeColonnes.addHeaderGroup(0, 5, new HeaderGroupConfig(i18nC.personneNaissance(), 1, 2));
		modeleDeColonnes.addHeaderGroup(0, 7, new HeaderGroupConfig(i18nC.personneDeces(), 1, 3));
		
		HashMap<String, String> virtualFields = new HashMap<String, String>();
		virtualFields.put("_role_", "ccap_id_role");
		virtualFields.put("_etat_", "");
		
		// Grille
		GrillePaginable<ModelData> grillePaginable = new GrillePaginable<ModelData>(modelTypeCollectionAPersonne, virtualFields, proxyCollectionAPersonne, colonnes, modeleDeColonnes);
		
		// Rajouter des écouteurs
		grillePaginable.getStore().addListener(Store.Update, new Listener<StoreEvent<ModelData>>() {
			public void handleEvent(StoreEvent<ModelData> ce) {
				if (ce.getRecord().isModified("_role_") && ce.getModel().get("_etat_") == null || !ce.getModel().get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
					ce.getModel().set("_etat_", aDonnee.ETAT_MODIFIE);
				}
			}
		});
		
		return grillePaginable;
	}
	
	private ColumnConfig creerColonneRole() {
		typeRelationCombo = new ComboBox<Valeur>();
		typeRelationCombo.setForceSelection(true);
		typeRelationCombo.setTriggerAction(TriggerAction.ALL);
		typeRelationCombo.setDisplayField("nom");
		typeRelationCombo.setStore(new ListStore<Valeur>());
		typeRelationCombo.setEditable(false);
		typeRelationCombo.addStyleName(ComposantClass.OBLIGATOIRE);
		typeRelationCombo.addListener(Events.Select, Formulaire.creerEcouteurChampObligatoire());
 
		CellEditor editeurRelation = new CellEditor(typeRelationCombo) {
			
			// Sert à retourner un ModelData à partir d'une String (la string est passée par le Renderer)
			public Object preProcessValue(Object valeur) {		
				Valeur retour = null;
				if (valeur != null ) {
					if (typeRelationCombo.getStore().findModel("nom", valeur.toString()) != null) {
						retour = typeRelationCombo.getStore().findModel("nom", valeur.toString());
					} else if (typeRelationCombo.getStore().findModel("abr", valeur.toString()) != null) {
						retour = typeRelationCombo.getStore().findModel("abr", valeur.toString());
					} else if (typeRelationCombo.getStore().findModel("id_valeur", valeur.toString()) != null) {
						retour = typeRelationCombo.getStore().findModel("id_valeur", valeur.toString());
					}
				}
				return retour;
			}
			
			// Sert à retourner un String à Partir d'une Valeur
			// en postProcess on remplace la valeur du champ par l'Id de la valeur au lieu de son Nom
			public Object postProcessValue(Object valeur) {	
				String retour = null;
				if (valeur != null ) {
					if (valeur instanceof Valeur) {
						Valeur valeurOntologie = (Valeur) valeur;
						String id = valeurOntologie.getId();
						retour = id;
					}
				}
				return retour;  
			}
		};
		
		// Sert à afficher le nom du role au lieu de l'id
		GridCellRenderer<ModelData> relationRendu = new GridCellRenderer<ModelData>() {
			public String render(ModelData modele, String property, ColumnData config, int rowIndex, int colIndex, ListStore<ModelData> store, Grid<ModelData> grille) {
				// Gestion du texte afficher dans la cellule				
				String role = modele.get("_role_");
				if (typeRelationCombo.getStore() != null && typeRelationCombo.getStore().getCount() > 0 && role.matches("[0-9]+")) {					
					role = typeRelationCombo.getStore().findModel("id_valeur", role).getNom();
				}
				return role;
			}
		};
		ColumnConfig typeRelationColonne = new ColumnConfig("_role_", i18nC.typeRelationPersonneCollection(), 75);
		typeRelationColonne.setEditor(editeurRelation);
		typeRelationColonne.setRenderer(relationRendu);
		
		return typeRelationColonne;
	}
	
	public ColumnConfig creerColonneDeces() {
		GridCellRenderer<ModelData> decesRendu = new GridCellRenderer<ModelData>() {
			public String render(ModelData modele, String property, ColumnData config, int rowIndex, int colIndex, ListStore<ModelData> store, Grid<ModelData> grid) {
				CollectionAPersonne cap = new CollectionAPersonne(modele);
				String deces = cap.getPersonne().getDeces();
				if (listeIon != null && cap.getPersonne().getDeces().matches("[0-9]+")) {
					deces = listeIon.findModel("id_valeur", cap.getPersonne().getDeces()).getNom();
				}
				modele.set("_deces_", deces);
				return deces;
			}
		};
		ColumnConfig decesColonne = new ColumnConfig("_deces_", Mediateur.i18nC.personneDecedeeInterogation(), 50);
		decesColonne.setRenderer(decesRendu);
		return decesColonne;
	}
	
	public void actualiserEtatBoutonsBarreOutils() {
		
		// Activation des boutons si la grille contient un élément
		if (grille.getStore().getCount() > 0) {  
			personnesBoutonSupprimer.enable();
			personnesBoutonModifier.enable();
		}
		// Désactivation des boutons si la grille ne contient plus d'élément
		if (grille.getStore().getCount() == 0) {  
			personnesBoutonSupprimer.disable();
			personnesBoutonModifier.disable();
		}
	}
	
	public void rafraichir(Object nouvellesDonnees) {
		if (nouvellesDonnees instanceof ValeurListe) {
			ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
			rafraichirValeurListe(listeValeurs);
		} else if (nouvellesDonnees instanceof Information) {
			Information info = (Information) nouvellesDonnees;
			rafraichirInformation(info);
		} else {
			GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
		}
	}
	
	private void rafraichirValeurListe(ValeurListe listeValeurs) {		
		if (listeValeurs.getId().equals(config.getListeId("ion"))) {
			listeIon = new ListStore<Valeur>();
			listeIon.add(listeValeurs.toList());
		} else if (listeValeurs.getId().equals(config.getListeId("relationPersonneCollection"))) {
			Formulaire.rafraichirComboBox(listeValeurs, typeRelationCombo);
		} else {
			GWT.log("Gestion de la liste "+listeValeurs.getId()+" non implémenté!", null);
		}
	}
	
	public void rafraichirInformation(Information info) {
		if (info.getMessages() != null && !info.getMessages().toString().equals("[]")) {
			GWT.log("MESSAGES:\n"+info.getMessages().toString(), null);
		}
		String type = info.getType();
		if (info.getType().equals("liste_collection_a_personne")) {
			if (info.getDonnee(0) != null) {
				collection.setPersonnesLiees((CollectionAPersonneListe) info.getDonnee(0));
			}
		} else if (info.getType().equals("ajout_collection")) {
			if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String) {
				String collectionId = (String) info.getDonnee(0);
				
				// Suite à la récupération de l'id de la collection nouvellement ajoutée nous ajoutons les personnes liées
				// En mode AJOUT, il ne peut que y avoir des personnes liées ajoutées
				mediateur.ajouterCollectionAPersonne(this, collectionId, personnesAjoutees);
			}
		} else if (type.equals("personne_modifiee")) {
			if (info.getDonnee(0) != null) {
				Personne personne = (Personne) info.getDonnee(0);				
				ModelData personneDansGrille = grille.getStore().findModel("ccap_id_personne", personne.getId());
				int index = grille.getStore().indexOf(personneDansGrille);
				grille.getStore().remove(personneDansGrille);
				String role = "";
				if(personneDansGrille != null) {
					role = (String) personneDansGrille.get("_role_");
				}
				ajouterDansGrille(personne, role, index);
			}
		} else if (type.equals("personne_ajoutee")) {
			if (info.getDonnee(0) != null) {
				Personne personne = (Personne) info.getDonnee(0);
				ajouterDansGrille(personne);
			}
		} else if (info.getType().equals("modif_collection_a_personne")) {
			InfoLogger.display("Modification des personnes liées à la collection", info.toString());
		} else if (info.getType().equals("suppression_collection_a_personne")) {
			InfoLogger.display("Suppression des personnes liées à la collection", info.toString());
			actualiserGrille();
		} else if (info.getType().equals("ajout_collection_a_personne")) {
			InfoLogger.display("Ajout des personnes liées à la collection", info.toString());
		}
	}
	
	public ArrayList<String> verifier() {
		ArrayList<String> messages = new ArrayList<String>();
		String personneNumero = "";
		int nbrePersonne = grille.getStore().getCount();
		
		if (nbrePersonne > 0) {
			for (int i = 0; i < nbrePersonne; i++) {
				if (grille.getStore().getAt(i).get("_role_").equals("")) {
					personneNumero += (i != 0 ? ", " : "")+(i+1);
				}
			}
			if (!personneNumero.equals("")) {
				messages.add("Veuillez indiquez le type de relation existant entre la collection et les personnes numéros : "+personneNumero);
			}
		}
		
		return messages;
	}
	
	public void collecter() {
		if (etreAccede()) {
			int nbrePersonne = grille.getStore().getCount();
			for (int i = 0; i < nbrePersonne; i++) {
				CollectionAPersonne relationCollectionPersonne = new CollectionAPersonne(grille.getStore().getAt(i));
				relationCollectionPersonne.set("_role_", grille.getStore().getAt(i).get("_role_"));
				
				if (grille.getStore().getAt(i).get("_etat_") != null) {
					
					if (grille.getStore().getAt(i).get("_etat_").equals(aDonnee.ETAT_MODIFIE)) {
						// Comme il est impossible de modifier les relations nous supprimons l'ancien enregistrement et ajoutons un nouveau avec le nouveau id_role
						personnesSupprimees.put("id"+idGenere++, relationCollectionPersonne);
						
						CollectionAPersonne relationAAjouter = (CollectionAPersonne) relationCollectionPersonne.cloner(new CollectionAPersonne());
						corrigerChampsGrille(relationAAjouter);// Nous modifions l'id_role
						personnesAjoutees.put("id"+idGenere++, relationAAjouter);
					} 
					if (grille.getStore().getAt(i).get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
						corrigerChampsGrille(relationCollectionPersonne);// Nous modifions l'id_role
						personnesAjoutees.put("id"+idGenere++, relationCollectionPersonne);
					}
					// Initialisation de la grille
					grille.getStore().getAt(i).set("_etat_", "");
				}
			}
			grille.getStore().commitChanges();
		}
	}
	
	private void corrigerChampsGrille(CollectionAPersonne relationCollectionPersonne) {
		String role = relationCollectionPersonne.get("_role_");
		String champModele = "nom";
		if (role.matches("[0-9]+")) {
			champModele = "id_valeur";
		}
 
		if (typeRelationCombo.getStore().findModel(champModele, role) != null) {
			String idRole = typeRelationCombo.getStore().findModel(champModele, role).getId();
			relationCollectionPersonne.setIdRole(idRole);
		}
	}
 
	public void soumettre() {
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
			
			if (personnesAjoutees.size() == 0 && personnesSupprimees.size() == 0) {
				//InfoLogger.display("Modification des personnes liées", "Rien n'a été enregistré car le formulaire n'a pas été modifié.");
			} else {
				// Ajout des relations CollectionAPersonne
				if (personnesAjoutees.size() != 0) {
					mediateur.ajouterCollectionAPersonne(this, collection.getId(), personnesAjoutees);
				}
				// Suppression des relations StructureAPersonne
				if (personnesSupprimees.size() != 0) {
					mediateur.supprimerCollectionAPersonne(this, personnesSupprimees);
				}
			}
		}
	}
	
	private void actualiserGrille() {
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
			mediateur.selectionnerCollectionAPersonne(this, collection.getId(), null, null);
		} else {
			grille.getStore().removeAll();
			layout();
		}
	}
}

Subversion Repositories eFlore/Applications.coel

(root)/trunk/src/org/tela_botanica/client/vues/collection/CollectionFormPersonne.java @ 1800 – Rev 1617 → 1630

Rev 1617		Rev 1630
1	`package org.tela_botanica.client.vues.collection;`	1	`package org.tela_botanica.client.vues.collection;`
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.List;`	5	`import java.util.List;`
6	`import java.util.Map;`	6	`import java.util.Map;`
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.ProxyCollectionAPersonne;`	13	`import org.tela_botanica.client.composants.pagination.ProxyCollectionAPersonne;`
14	`import org.tela_botanica.client.composants.pagination.ProxyPersonnes;`	14	`import org.tela_botanica.client.composants.pagination.ProxyPersonnes;`
15	`import org.tela_botanica.client.images.Images;`	15	`import org.tela_botanica.client.images.Images;`
16	`import org.tela_botanica.client.interfaces.Rafraichissable;`	16	`import org.tela_botanica.client.interfaces.Rafraichissable;`
17	`import org.tela_botanica.client.modeles.Information;`	17	`import org.tela_botanica.client.modeles.Information;`
18	`import org.tela_botanica.client.modeles.Valeur;`	18	`import org.tela_botanica.client.modeles.Valeur;`
19	`import org.tela_botanica.client.modeles.ValeurListe;`	19	`import org.tela_botanica.client.modeles.ValeurListe;`
20	`import org.tela_botanica.client.modeles.aDonnee;`	20	`import org.tela_botanica.client.modeles.aDonnee;`
21	`import org.tela_botanica.client.modeles.collection.Collection;`	21	`import org.tela_botanica.client.modeles.collection.Collection;`
22	`import org.tela_botanica.client.modeles.collection.CollectionAPersonne;`	22	`import org.tela_botanica.client.modeles.collection.CollectionAPersonne;`
23	`import org.tela_botanica.client.modeles.collection.CollectionAPersonneListe;`	23	`import org.tela_botanica.client.modeles.collection.CollectionAPersonneListe;`
24	`import org.tela_botanica.client.modeles.personne.Personne;`	24	`import org.tela_botanica.client.modeles.personne.Personne;`
25	`import org.tela_botanica.client.synchronisation.Sequenceur;`	25	`import org.tela_botanica.client.synchronisation.Sequenceur;`
26	`import org.tela_botanica.client.util.Debug;`	26	`import org.tela_botanica.client.util.Debug;`
27	`import org.tela_botanica.client.vues.FenetreForm;`	27	`import org.tela_botanica.client.vues.FenetreForm;`
28	`import org.tela_botanica.client.vues.Formulaire;`	28	`import org.tela_botanica.client.vues.Formulaire;`
29	`import org.tela_botanica.client.vues.FormulaireBarreValidation;`	29	`import org.tela_botanica.client.vues.FormulaireBarreValidation;`
30	`import org.tela_botanica.client.vues.FormulaireOnglet;`	30	`import org.tela_botanica.client.vues.FormulaireOnglet;`
31	`import org.tela_botanica.client.vues.personne.PersonneForm;`	31	`import org.tela_botanica.client.vues.personne.PersonneForm;`
32		32
33	`import com.extjs.gxt.ui.client.Style.Scroll;`	33	`import com.extjs.gxt.ui.client.Style.Scroll;`
34	`import com.extjs.gxt.ui.client.data.ModelData;`	34	`import com.extjs.gxt.ui.client.data.ModelData;`
35	`import com.extjs.gxt.ui.client.data.ModelType;`	35	`import com.extjs.gxt.ui.client.data.ModelType;`
36	`import com.extjs.gxt.ui.client.event.BaseEvent;`	36	`import com.extjs.gxt.ui.client.event.BaseEvent;`
37	`import com.extjs.gxt.ui.client.event.ButtonEvent;`	37	`import com.extjs.gxt.ui.client.event.ButtonEvent;`
38	`import com.extjs.gxt.ui.client.event.Events;`	38	`import com.extjs.gxt.ui.client.event.Events;`
39	`import com.extjs.gxt.ui.client.event.FieldEvent;`	39	`import com.extjs.gxt.ui.client.event.FieldEvent;`
40	`import com.extjs.gxt.ui.client.event.Listener;`	40	`import com.extjs.gxt.ui.client.event.Listener;`