WebSVN – eFlore/Applications.coel – Diff – /branches/v1.0-syrah/src/org/tela_botanica/client/Mediateur.java


package org.tela_botanica.client;
 
import java.util.Iterator;
import java.util.List;
 
import org.tela_botanica.client.composants.AideFenetre;
import org.tela_botanica.client.composants.IdentificationFenetre;
import org.tela_botanica.client.composants.ParametreFenetre;
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.i18n.ErrorMessages;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionListe;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.MenuApplicationId;
import org.tela_botanica.client.modeles.Personne;
import org.tela_botanica.client.modeles.PersonneListe;
import org.tela_botanica.client.modeles.Projet;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.PublicationListe;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureAPersonne;
import org.tela_botanica.client.modeles.StructureAPersonneListe;
import org.tela_botanica.client.modeles.StructureConservation;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.modeles.StructureValorisation;
import org.tela_botanica.client.modeles.Utilisateur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.vues.CollectionForm;
import org.tela_botanica.client.vues.CollectionListeVue;
import org.tela_botanica.client.vues.CollectionVue;
import org.tela_botanica.client.vues.ContenuVue;
import org.tela_botanica.client.vues.EnteteVue;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.PersonneForm;
import org.tela_botanica.client.vues.PublicationForm;
import org.tela_botanica.client.vues.StructureForm;
import org.tela_botanica.client.vues.PersonneVue;
import org.tela_botanica.client.vues.PopupChargement;
import org.tela_botanica.client.vues.PublicationVue;
import org.tela_botanica.client.vues.StatutVue;
import org.tela_botanica.client.vues.StructureVue;
import org.tela_botanica.client.vues.MenuVue;
 
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.LayoutRegion;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.MessageBoxEvent;
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.Dialog;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.Viewport;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.layout.BorderLayout;
import com.extjs.gxt.ui.client.widget.layout.BorderLayoutData;
import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.Dictionary;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.RootPanel;
 
public class Mediateur implements Rafraichissable {
	
	private Viewport viewport;
	private Modele modele = null;
	public static final Constantes i18nC = getI18nConstante();
	public static final ErrorMessages i18nM = getI18nMessage();
	
	private EnteteVue panneauNord = null;
	private MenuVue panneauOuest = null;
	private ContenuVue panneauCentre = null;
	private StatutVue panneauSud = null;
	private Rafraichissable contenuPanneauCentre = null;
	
	private IdentificationFenetre fenetreIdentification = null;
	
	public Mediateur() {
		// Enregistrement du Médiateur dans le Registre
		Registry.register(RegistreId.MEDIATEUR, this);
		
		// Création du Modèle qui s'enregistre lui même dans le Registre
		modele = new Modele();
 
		// Création du Viewport qui contient la disposition globale de l'application
		viewport = new Viewport();
		viewport.setLayout(new BorderLayout());
 
	    //Initialisation du Registre
		initialiserRegistre();
 
		// Création des différents panneaux
	    creerPanneauNord();
	    creerPanneauOuest();
	    creerPanneauCentral();
	    creerPanneauSud();
		
		// Connection de l'utilisateur
		connecterUtilisateur(null, null);
		
		// Retour à GWT du Viewport une fois constuit
		RootPanel.get().add(viewport);
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION de l'I18N et du REGISTRE
	//+----------------------------------------------------------------------------------------------------------------+
	protected static Constantes getI18nConstante() {
		return GWT.create(Constantes.class);
	}
	
	protected static ErrorMessages getI18nMessage() {
		return GWT.create(ErrorMessages.class);
	}
	
	protected void initialiserRegistre() {
		Registry.register(RegistreId.APPLI_NOM, i18nC.appliNom());
		Registry.register(RegistreId.APPLI_CODE, i18nC.appliCode());
		Registry.register(RegistreId.APPLI_VERSION, i18nC.appliVersionNumero());
		Registry.register(RegistreId.APPLI_REVISION, "$Revision: 501 $");
 
		Registry.register(RegistreId.CONFIG, new Configuration());
		Registry.register(RegistreId.POPUP_CHARGEMENT, new PopupChargement(this));
		Registry.register(RegistreId.UTILISATEUR_COURANT, new Utilisateur(null, false));
		Registry.register(RegistreId.PROJET_COURANT, new Projet());
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION des PANNEAUX PRINCIPAUX
	//+----------------------------------------------------------------------------------------------------------------+
	
	private void creerPanneauNord() {
		panneauNord = new EnteteVue(this);
		
		BorderLayoutData regionNord = new BorderLayoutData(LayoutRegion.NORTH, 100);  
		regionNord.setCollapsible(true);
		regionNord.setFloatable(true);
		regionNord.setSplit(false);
		regionNord.setMargins(new Margins(5, 5, 0, 5));
		
		viewport.add(panneauNord, regionNord);
	}
	
	private void creerPanneauOuest() {
		panneauOuest = new MenuVue(this); 
		
		BorderLayoutData regionOuest = new BorderLayoutData(LayoutRegion.WEST, 200);  
		regionOuest.setSplit(true);
		regionOuest.setCollapsible(true);  
		regionOuest.setMargins(new Margins(5));
 
		viewport.add(panneauOuest, regionOuest);
	}
 
	private void creerPanneauCentral() {
		panneauCentre = new ContenuVue(this);
 
		BorderLayoutData regionCentre = new BorderLayoutData(LayoutRegion.CENTER);  
		regionCentre.setMargins(new Margins(5, 5, 5, 0));
 
		viewport.add(panneauCentre, regionCentre);
	}
	
	private void creerPanneauSud() {
		panneauSud = new StatutVue();
		
		BorderLayoutData regionSud = new BorderLayoutData(LayoutRegion.SOUTH, 20); 
		regionSud.setCollapsible(true);
		regionSud.setFloatable(true);
		regionSud.setSplit(false);
		regionSud.setMargins(new Margins(0));
		
		viewport.add(panneauSud, regionSud);
	}
 
	public void actualiserPanneauCentral() {
		panneauCentre.layout();
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION du MENU
	//+----------------------------------------------------------------------------------------------------------------+
	
	public void clicMenu(String codeMenuClique) {
		activerChargement(codeMenuClique);
		if (codeMenuClique.equals(MenuApplicationId.STRUCTURE)) {
			modele.selectionnerStructure(panneauCentre, getProjetId(), null);
		} else if (codeMenuClique.equals(MenuApplicationId.COLLECTION)) { 
			selectionnerCollection(panneauCentre, null);
		} else if (codeMenuClique.equals(MenuApplicationId.PERSONNE)) { 
			//modele.selectionnerPersonne(panneauCentre, null, getProjetId(), null);
			selectionnerPersonne(panneauCentre, null, null);
		} else if (codeMenuClique.equals(MenuApplicationId.PUBLICATION)) {
			modele.selectionnerPublications(panneauCentre);
		} else {
			GWT.log("Non implémenté! Menu id : "+codeMenuClique, null);
		}
		panneauCentre.layout();
	}
	
	public void activerChargement(String message) {
		afficherPopinChargement(); 
		panneauSud.showBusy(i18nC.chargement()+" "+message);
	}
	
	public void desactiverChargement() {
		masquerPopinChargement();
		panneauSud.clear();
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES FENÊTRES
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void ouvrirAide() {
		AideFenetre aideFenetre = new AideFenetre();
		aideFenetre.show();
		// FIXME : apparament le fade In/Fade Out pose problème sur les navigateurs...
		//aideFenetre.el().fadeIn(FxConfig.NONE);
	}
 
	public void ouvrirParametres() {
		ParametreFenetre parametresFenetre = new ParametreFenetre();
		parametresFenetre.show();
	}
 
	public void ouvrirIdentification() {
		fenetreIdentification = new IdentificationFenetre();
		fenetreIdentification.show();
	}
 
	public void ouvrirApplis(String id) {
		if (id.equals(ComposantId.MENU_CEL)) {
			Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getCelUrl(), "Carnet en ligne", "");
		} else if (id.equals(ComposantId.MENU_BEL)) {
			Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getCelUrl(), "Biblio en ligne", "");
		}
	}
 
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION de l'UTILISATEUR et de l'IDENTIFICATION
	//+----------------------------------------------------------------------------------------------------------------+
	/**
	 * Retourne l'identifiant de l'utilisateur courrant de l'application.
	 */
	public String getUtilisateurId() {
		String id = null;
		Utilisateur utilisateurCourant = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
		if (!utilisateurCourant.getId().equals("")) {
			id = utilisateurCourant.getId();
		}
		return id;
	}
	
	public void connecterUtilisateur(String login, String mdp) {
		modele.connecterUtilisateur(this, login, mdp);
	}
	
	public void deconnecterUtilisateur() {
		modele.deconnecterUtilisateur(this);
	}
	
	public void mettreAJourEtatIdentification(Utilisateur utilisateur) {
		// Mise à jour du registre
		Registry.register(RegistreId.UTILISATEUR_COURANT, utilisateur);
		// Création de l'information de mise à jour de l'utilisateur
		Information info = new Information("maj_utilisateur");
 
		// Rafraichissement de la fenêtre d'Identification
		if (fenetreIdentification != null) {
			fenetreIdentification.rafraichir(info);
		}
		
		// Rafraichissement du panneau Nord
		panneauNord.rafraichir(info);
 
		// Rafraichissement du panneau Centre
		if (contenuPanneauCentre != null) {
			contenuPanneauCentre.rafraichir(info);
		}
	}
 
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES VALEURS ET LISTES
	//+----------------------------------------------------------------------------------------------------------------+
 
 
 
 
 
 
 
 
 
	public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, String listeId)	{
		modele.obtenirListeValeurs(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId));
	}
	
	public void obtenirValeurEtRafraichir(Rafraichissable vue, String listeId, String identifiantValeur)	{
		modele.obtenirValeur(vue, "abv", ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), identifiantValeur);
	}
	
	public void obtenirListeRegionsEtRafraichir(Rafraichissable vue, String strListeId, String strPays)	{
		modele.obtenirListeRegion(vue, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(strListeId), strPays+".__");
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION des PROJETS
	//+----------------------------------------------------------------------------------------------------------------+
	
	/**
	 * Retourne l'identifiant du projet courrant de l'application.
	 */
	public String getProjetId() {
		String id = null;
		Projet projetCourant = (Projet) Registry.get(RegistreId.PROJET_COURANT);
		if (projetCourant != null && !projetCourant.getId().equals("")) {
			id = projetCourant.getId();
		}
		return id;
	}
	
	//Greg : ajout d'un écouteur pour le changement liste projet
	public void selectionnerProjets(Rafraichissable vueARafraichir)	{
		modele.selectionnerProjets(vueARafraichir);
	}
	
	public void afficherListeProjets(ProjetListe projets)	{
		panneauOuest.rafraichir(projets);
	}
	
	public void selectionnerProjetCourant(Projet projetSelectionne) {
		Registry.register(RegistreId.PROJET_COURANT, projetSelectionne);
		if (contenuPanneauCentre instanceof PersonneVue)	{
			//modele.selectionnerPersonne(contenuPanneauCentre, null, getProjetId(), null);
			selectionnerPersonne(contenuPanneauCentre, null, getProjetId());
			//FIXME Le rafraichissement du panneau ne se fait pas!
		} else if (contenuPanneauCentre instanceof StructureVue)	{
			modele.selectionnerStructure(contenuPanneauCentre, getProjetId(), null);
		} else if (contenuPanneauCentre instanceof CollectionVue)	{
			modele.selectionnerCollection(contenuPanneauCentre, getProjetId(), null);
		}
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES STRUCTURES
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void afficherListeStructures(StructureListe structuresACharger) {
		
		if (!(contenuPanneauCentre instanceof StructureVue))	{	
			panneauCentre.removeAll();
			StructureVue structureVue = new StructureVue(this);
			contenuPanneauCentre = structureVue;
			panneauCentre.add(structureVue);
			panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_LISTE);
		}
		contenuPanneauCentre.rafraichir(structuresACharger);
	}
	
	public void afficherFormStructure(String structureId) {
		String mode = Formulaire.MODE_AJOUTER;
		if (structureId != null) {
			mode = Formulaire.MODE_MODIFIER;
		}
		
		panneauCentre.removeAll();
		StructureForm structureForm = new StructureForm(this, mode);
		panneauCentre.add(structureForm);
 
		
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
			selectionnerStructure(structureForm, structureId);
			selectionnerStructureAPersonne(structureForm, structureId, StructureAPersonne.ROLE_EQUIPE);
		}
		
		panneauCentre.layout();
	}
	
	public void clicListeStructure(Structure structure) {
		contenuPanneauCentre.rafraichir(structure);
		if (structure != null && structure.getPersonnel() == null) {
			selectionnerStructureAPersonne(contenuPanneauCentre, structure.getId(), StructureAPersonne.ROLE_EQUIPE);
		} else {
			GWT.log("OK personnel déjà chargé", null);
		}
	}
 
	public void clicAjouterStructure() {
		afficherFormStructure(null);
	}
	
	public void clicModifierStructure(List<Structure> structureSelection) {
		if (structureSelection.size() == 0) {
			Info.display("Information", "Veuillez sélectionner une structure.");
		} else if (structureSelection.size() > 1) {
			Info.display("Information", "Veuillez sélectionner une seule structure à la fois.");
		} else if (structureSelection.size() == 1) {
			afficherFormStructure(structureSelection.get(0).getId());
		} else {
			Info.display("Erreur", "Une erreur est survenue dans la méthode clicModifierStructure() du Médiateur.");
		}
	}
	
	public void clicSupprimerStructure(final Rafraichissable vue, final List<Structure> structureSelection) {
		if (structureSelection.size() == 0) {
			Info.display("Information", "Veuillez sélectionner une structure.");
		} else if(structureSelection.size() > 0) {
			String titre = "Supprimer des structures";
			String message = "Êtes vous sur de vouloir supprimer les structures sélectionnées ?";
			if (structureSelection.size() == 1) {
				titre = "Supprimer une structure";
				message = "Êtes vous sur de vouloir supprimer la structure sélectionnée ?";
			}
			
			final Listener<MessageBoxEvent> suppressionEcouteur = new Listener<MessageBoxEvent>() { 
				public void handleEvent(MessageBoxEvent ce) {  
					Dialog dialog = (Dialog) ce.getComponent();
					Button btn = ce.getButtonClicked();  
 
					if (btn.getText().equals(dialog.yesText))	{
						String idStr = "" ;
						for(int i = 0 ; i < structureSelection.size() ; i++) {
							idStr += structureSelection.get(i).getId()+","; 
						}
						supprimerStructure(vue, idStr); 
					}
				}
			};
			
			MessageBox.confirm(titre, message, suppressionEcouteur);
		} else {
			Info.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerStructure() du Médiateur.");
		}
	}
	
	public void selectionnerStructure(Rafraichissable vue, String structureId) {
		modele.selectionnerStructure(vue, getProjetId(), structureId);
	}
	
	public void ajouterStructure(Rafraichissable vue, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
		modele.ajouterStructure(vue, getUtilisateurId(), structure, conservation, valorisation);
	}
	
	public void modifierStructure(Rafraichissable vue, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
		modele.modifierStructure(vue, getUtilisateurId(), structureId, structure, conservation, valorisation);
	}
	
	public void supprimerStructure(Rafraichissable vueARafraichir, String IdentifiantsStructureSepareParVirgule) {
		modele.supprimerStructure(vueARafraichir, getUtilisateurId(), IdentifiantsStructureSepareParVirgule);
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	// GESTION de la relation STRUCTURE A PERSONNE
	public void selectionnerStructureAPersonne(Rafraichissable vue, String structureId, String roleId) {
		GWT.log("Structure : "+structureId, null);
		modele.selectionnerStructureAPersonne(vue, getUtilisateurId(), null, structureId, roleId);
	}
	
	public void ajouterStructureAPersonne(Rafraichissable vue, String structureId, StructureAPersonneListe personnelAjoute) {
		if (personnelAjoute != null && personnelAjoute.size() > 0) {
			for (Iterator<String> it = personnelAjoute.keySet().iterator(); it.hasNext();) {
				modele.ajouterStructureAPersonne(vue, getUtilisateurId(), structureId, (StructureAPersonne) personnelAjoute.get(it.next()));
			}
		}
	}
	
	public void modifierStructureAPersonne(Rafraichissable vue, StructureAPersonneListe personnelModifie) {
		if (personnelModifie != null && personnelModifie.size() > 0) {
			GWT.log("Mediateur :modif", null);
			for (Iterator<String> it = personnelModifie.keySet().iterator(); it.hasNext();) {
				modele.modifierStructureAPersonne(vue, getUtilisateurId(), (StructureAPersonne) personnelModifie.get(it.next()));
			}
		}
	}
	
	public void supprimerStructureAPersonne(Rafraichissable vue, StructureAPersonneListe personnelSupprime) {
		if (personnelSupprime != null && personnelSupprime.size() > 0) {
			String idStrAPer = "" ;
			for (Iterator<String> it = personnelSupprime.keySet().iterator(); it.hasNext();) {
					idStrAPer += personnelSupprime.get(it.next()).getId()+"," ;
			}
			modele.supprimerStructureAPersonne(vue, getUtilisateurId(), idStrAPer);
		}
	}
 
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION des COLLECTIONS
	//+----------------------------------------------------------------------------------------------------------------+
	
	public void afficherListeCollections(CollectionListe collectionsACharger) {
		
		if (!(contenuPanneauCentre instanceof CollectionVue))	{
			panneauCentre.removeAll();
			CollectionVue collectionVue = new CollectionVue(this);
			panneauCentre.add(collectionVue);
			panneauCentre.setId(ComposantId.PANNEAU_COLLECTION_LISTE);
			contenuPanneauCentre = collectionVue;
		}	
		
		contenuPanneauCentre.rafraichir(collectionsACharger);
	}
	
	public void afficherFormCollection(String collectionId) {
		String mode = Formulaire.MODE_AJOUTER;
		if (collectionId != null) {
			mode = Formulaire.MODE_MODIFIER;
		}
		
		panneauCentre.removeAll();
		CollectionForm collectionForm = new CollectionForm(this, mode);
		panneauCentre.add(collectionForm);
		
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
			selectionnerCollection(collectionForm, collectionId);
		}
		
		panneauCentre.layout();
	}
	
	public void clicListeCollection(Collection collectionCliquee) {
		contenuPanneauCentre.rafraichir(collectionCliquee);
	}
	
	public void clicAjouterCollection() {
		// TODO Auto-generated method stub
		
	}
 
	public void clicModifierCollection(List<Collection> selection) {
		if (selection.size() == 0) {
			Info.display("Information", "Veuillez sélectionner une collection.");
		} else if (selection.size() > 1) {
			Info.display("Information", "Veuillez sélectionner une seule collection à la fois.");
		} else if (selection.size() == 1) {
			afficherFormCollection(selection.get(0).getId());
		} else {
			Info.display("Erreur", "Une erreur est survenue dans la méthode clicModifierCollection() du Médiateur.");
		}
	}
 
	public void clicSupprimerCollection(CollectionListeVue collectionListeVue, List<Collection> collectionsASupprimer) {
		// TODO Auto-generated method stub
		
	}
 
	public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId) {
		modele.selectionnerCollection(vueARafraichir, getProjetId(), collectionId);
	}
	
	public void ajouterCollection(Rafraichissable vueARafraichir, Collection collection) {
		modele.ajouterCollection(vueARafraichir, getUtilisateurId(), collection);
	}
	
	public void modifierCollection(Rafraichissable vueARafraichir, Collection collection) {
		modele.modifierCollection(vueARafraichir, getUtilisateurId(), collection);
	}
	
	public void supprimerCollection(Rafraichissable vueARafraichir, String IdentifiantsCollectionSepareParVirgule) {
		modele.supprimerCollection(vueARafraichir, getUtilisateurId(), IdentifiantsCollectionSepareParVirgule);
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES PERSONNES
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void clicListePersonne(Personne personne)	{
		contenuPanneauCentre.rafraichir(personne);
	}
 
	public void afficherListePersonnes(PersonneListe personnesACharger)	{
		
		if (!(contenuPanneauCentre instanceof PersonneVue))	{
			panneauCentre.removeAll();
			PersonneVue personneVue = new PersonneVue(this);
			contenuPanneauCentre = personneVue;
			panneauCentre.add(personneVue);
		}	
		
		contenuPanneauCentre.rafraichir(personnesACharger);
	}
 
	public void clicAjouterPersonne()	{
		afficherPopinChargement();
		 
		panneauCentre.removeAll();
		PersonneForm formulairePersonneVue = new PersonneForm(PersonneForm.MODE_AJOUTER);
		contenuPanneauCentre = formulairePersonneVue;
		panneauCentre.add(formulairePersonneVue);
		panneauCentre.layout();
	}
	
	public void clicModifierPersonne(Personne personne)	{
		if (personne!=null)	{
			panneauCentre.removeAll();
			PersonneForm formulairePersonneVue = new PersonneForm(PersonneForm.MODE_MODIFIER);
			contenuPanneauCentre = formulairePersonneVue;
			panneauCentre.add(formulairePersonneVue);
			
			selectionnerPersonne(formulairePersonneVue, personne, null);
			
			panneauCentre.layout();			
		}
	}
 
	public void selectionnerPersonne(Rafraichissable vue, Personne personne, String projetId)	{
		int nbElements = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); 
		selectionnerPersonne(vue, personne, projetId, 0, nbElements);
	}
	
	public void selectionnerPersonne(Rafraichissable vue, Personne personne, String projetId, int start, int nbElements)	{
		String personneId = null;
		if (personne!=null)	{
			personneId = personne.getId();
		}
		modele.selectionnerPersonne(vue, personneId, projetId, null, start, nbElements);
	}
	
	public void clicSupprimerPersonne(final Rafraichissable vue,final List<Personne> personneSelection) {
		if (personneSelection.size() == 0) {
			Info.display("Information", "Veuillez sélectionner une personne.");
		} else if(personneSelection.size() > 0) {
			String message = "Êtes vous sur de vouloir supprimer les personnes sélectionnées ?";
			if (personneSelection.size() == 1) {
				message = "Êtes vous sur de vouloir supprimer la personne sélectionnée ?";
			}
			
			final Listener<MessageBoxEvent> listenerSuppression = new Listener<MessageBoxEvent>() { 
				public void handleEvent(MessageBoxEvent ce) {
					Dialog dialog = (Dialog) ce.getComponent();
					Button btn = ce.getButtonClicked();
 
					if (btn.getText().equals(dialog.yesText)) {
						String idStr = "" ;
						Iterator<Personne> itPersonne = personneSelection.iterator();
						while (itPersonne.hasNext()) {
							Personne personneCourante = itPersonne.next();
							idStr += personneCourante.getId();
							idStr +=",";
						}
						modele.supprimerPersonne(vue, idStr);  
					}
				}
			};
			
			MessageBox.confirm("Supprimer une personne", message, listenerSuppression);
		} else {
			Info.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerPersonne() du Médiateur.");
		}
	}
 
	public void selectionnerPersonneParNomComplet(Rafraichissable vueARafraichir, String projetId, String nomComplet) {
		modele.selectionnerPersonne(vueARafraichir, null, projetId, nomComplet, 0, -1);		
	}
	
	public void enregistrerPersonne(Rafraichissable vue, Personne personne){
		if (personne.getId()!=null && !personne.getId().trim().equals("")) {	
			modele.modifierPersonne(vue, personne);
		}	else {
			modele.ajouterPersonne(vue, personne);
		}
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES PUBLICATIONS
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void afficherListePublication(PublicationListe nouvelleDonnees) {
		
		if (!(contenuPanneauCentre instanceof PersonneVue))	{
			panneauCentre.removeAll();
			PublicationVue publicationVue = new PublicationVue(this) ;
			panneauCentre.removeAll();
			panneauCentre.add(publicationVue);
			contenuPanneauCentre = publicationVue;
		}	
		
		contenuPanneauCentre.rafraichir(nouvelleDonnees);
		
	}
 
	public void clicListePublication(Publication publication) {
		panneauCentre.rafraichir(publication);	
	}
 
	public void clicAjouterPublication() {
		panneauCentre.removeAll();
		PublicationForm publicationForm = new PublicationForm();
		panneauCentre.add(publicationForm);
		panneauCentre.setId(ComposantId.PANNEAU_FORM_PUBLICATION);
		panneauCentre.layout();
	}
	
	public void clicModifierPublication(List<Publication> publicationListe) {
		if(publicationListe.size() <= 0) {
			MessageBox.alert("Attention", "Vous devez sélectionner une publication", null);
		} else {
			Publication pubAModifier = publicationListe.get(publicationListe.size() -1);
			panneauCentre.removeAll();
			PublicationForm publicationForm = new PublicationForm();
			panneauCentre.add(publicationForm);
			panneauCentre.setId(ComposantId.PANNEAU_FORM_PUBLICATION);
			panneauCentre.layout();
			publicationForm.rafraichir(pubAModifier);
		}
	}
	
	public void clicSupprimerPublication(final List<Publication> publicationListe) {
		if (publicationListe.size() <= 0) {
			MessageBox.alert("Attention", "Vous devez sélectionner une publication", null); 
		} else {
			String message = "Voulez-vous vraiment supprimer ces publication ?";
			if(publicationListe.size() == 1) {
				message = "Voulez-vous vraiment supprimer cette publication ?";
			}
			
			final Listener<MessageBoxEvent> listenerSuppression = new Listener<MessageBoxEvent>() { 
				public void handleEvent(MessageBoxEvent ce) {  
					Dialog dialog = (Dialog) ce.getComponent();
				    Button btn = ce.getButtonClicked();  
				    	   
				    if (btn.getText().equals(dialog.yesText)) {
				    	modele.supprimerPublication(contenuPanneauCentre, getUtilisateurId(),publicationListe);  
				    }
				}
			};
				     
			MessageBox.confirm("Supprimer une publication", message, listenerSuppression);
		}
	}
 
	public void ajouterPublication(PublicationForm publicationForm, Publication publi) {
		modele.ajouterPublication(contenuPanneauCentre, getUtilisateurId(), publi);
	}
	
	public void modifierPublication(PublicationForm publicationForm, Publication publi) {
		modele.modifierPublication(contenuPanneauCentre, getUtilisateurId(), publi);
	}
 
	public void clicObtenirListeEditeurs(Rafraichissable vueARafraichir) {
		modele.selectionnerStructure(vueARafraichir, null, null);
	}
 
	public void clicObtenirListeAuteurs(Rafraichissable vueARafraichir) {
		//modele.selectionnerPersonne(vueARafraichir, null, null, null);
		selectionnerPersonne(vueARafraichir, null, null);
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												RAFRAICHISSEMENT
	//+----------------------------------------------------------------------------------------------------------------+
	
	public void rafraichir(Object nouvelleDonnees) {
		if (nouvelleDonnees instanceof Utilisateur) {
			mettreAJourEtatIdentification((Utilisateur) nouvelleDonnees);
		} else {
			GWT.log("Pas de correspondance dans la méthode rafraichir() de la classe "+this.getClass(), null);
		}
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION du STATUT
	//+----------------------------------------------------------------------------------------------------------------+
	
	public void afficherPopinChargement()	{
		((PopupChargement) Registry.get(RegistreId.POPUP_CHARGEMENT)).center();
	}
		
	public void masquerPopinChargement()	{		
		((PopupChargement) Registry.get(RegistreId.POPUP_CHARGEMENT)).hide();
	}
 
}

Subversion Repositories eFlore/Applications.coel

(root)/branches/v1.0-syrah/src/org/tela_botanica/client/Mediateur.java @ 1330 – Rev 626 → 641

Rev 626		Rev 641
1	`package org.tela_botanica.client;`	1	`package org.tela_botanica.client;`
2		2
3	`import java.util.Iterator;`	3	`import java.util.Iterator;`
4	`import java.util.List;`	4	`import java.util.List;`
5		5
6	`import org.tela_botanica.client.composants.AideFenetre;`	6	`import org.tela_botanica.client.composants.AideFenetre;`
7	`import org.tela_botanica.client.composants.IdentificationFenetre;`	7	`import org.tela_botanica.client.composants.IdentificationFenetre;`
8	`import org.tela_botanica.client.composants.ParametreFenetre;`	8	`import org.tela_botanica.client.composants.ParametreFenetre;`
9	`import org.tela_botanica.client.i18n.Constantes;`	9	`import org.tela_botanica.client.i18n.Constantes;`
10	`import org.tela_botanica.client.i18n.ErrorMessages;`	10	`import org.tela_botanica.client.i18n.ErrorMessages;`
11	`import org.tela_botanica.client.interfaces.Rafraichissable;`	11	`import org.tela_botanica.client.interfaces.Rafraichissable;`
12	`import org.tela_botanica.client.modeles.Collection;`	12	`import org.tela_botanica.client.modeles.Collection;`
13	`import org.tela_botanica.client.modeles.CollectionListe;`	13	`import org.tela_botanica.client.modeles.CollectionListe;`
14	`import org.tela_botanica.client.modeles.Configuration;`	14	`import org.tela_botanica.client.modeles.Configuration;`
15	`import org.tela_botanica.client.modeles.Information;`	15	`import org.tela_botanica.client.modeles.Information;`
16	`import org.tela_botanica.client.modeles.MenuApplicationId;`	16	`import org.tela_botanica.client.modeles.MenuApplicationId;`
17	`import org.tela_botanica.client.modeles.Personne;`	17	`import org.tela_botanica.client.modeles.Personne;`
18	`import org.tela_botanica.client.modeles.PersonneListe;`	18	`import org.tela_botanica.client.modeles.PersonneListe;`
19	`import org.tela_botanica.client.modeles.Projet;`	19	`import org.tela_botanica.client.modeles.Projet;`
20	`import org.tela_botanica.client.modeles.ProjetListe;`	20	`import org.tela_botanica.client.modeles.ProjetListe;`
21	`import org.tela_botanica.client.modeles.Publication;`	21	`import org.tela_botanica.client.modeles.Publication;`
22	`import org.tela_botanica.client.modeles.PublicationListe;`	22	`import org.tela_botanica.client.modeles.PublicationListe;`
23	`import org.tela_botanica.client.modeles.Structure;`	23	`import org.tela_botanica.client.modeles.Structure;`
24	`import org.tela_botanica.client.modeles.StructureAPersonne;`	24	`import org.tela_botanica.client.modeles.StructureAPersonne;`
25	`import org.tela_botanica.client.modeles.StructureAPersonneListe;`	25	`import org.tela_botanica.client.modeles.StructureAPersonneListe;`
26	`import org.tela_botanica.client.modeles.StructureConservation;`	26	`import org.tela_botanica.client.modeles.StructureConservation;`
27	`import org.tela_botanica.client.modeles.StructureListe;`	27	`import org.tela_botanica.client.modeles.StructureListe;`
28	`import org.tela_botanica.client.modeles.StructureValorisation;`	28	`import org.tela_botanica.client.modeles.StructureValorisation;`
29	`import org.tela_botanica.client.modeles.Utilisateur;`	29	`import org.tela_botanica.client.modeles.Utilisateur;`
30	`import org.tela_botanica.client.modeles.ValeurListe;`	30	`import org.tela_botanica.client.modeles.ValeurListe;`
-		31	`import org.tela_botanica.client.vues.CollectionForm;`
31	`import org.tela_botanica.client.vues.CollectionListeVue;`	32	`import org.tela_botanica.client.vues.CollectionListeVue;`
32	`import org.tela_botanica.client.vues.CollectionVue;`	33	`import org.tela_botanica.client.vues.CollectionVue;`
33	`import org.tela_botanica.client.vues.ContenuVue;`	34	`import org.tela_botanica.client.vues.ContenuVue;`
34	`import org.tela_botanica.client.vues.EnteteVue;`	35	`import org.tela_botanica.client.vues.EnteteVue;`
-		36	`import org.tela_botanica.client.vues.Formulaire;`
35	`import org.tela_botanica.client.vues.PersonneForm;`	37	`import org.tela_botanica.client.vues.PersonneForm;`
36	`import org.tela_botanica.client.vues.PublicationForm;`	38	`import org.tela_botanica.client.vues.PublicationForm;`
37	`import org.tela_botanica.client.vues.StructureForm;`	39	`import org.tela_botanica.client.vues.StructureForm;`
38	`import org.tela_botanica.client.vues.PersonneVue;`	40	`import org.tela_botanica.client.vues.PersonneVue;`