WebSVN – eFlore/Applications.coel – Diff – /trunk/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.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.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.PersonneForm;
import org.tela_botanica.client.vues.PublicationForm;
import org.tela_botanica.client.vues.StructureForm;
import org.tela_botanica.client.vues.PersonneDetailVue;
import org.tela_botanica.client.vues.PersonneVue;
import org.tela_botanica.client.vues.PopupChargement;
import org.tela_botanica.client.vues.PublicationDetailVue;
import org.tela_botanica.client.vues.PublicationVue;
import org.tela_botanica.client.vues.StatutVue;
import org.tela_botanica.client.vues.StructureDetailVue;
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.ComponentEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.WindowEvent;
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.StatusBar;
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.user.client.Window;
import com.google.gwt.user.client.ui.RootPanel;
 
public class Mediateur implements Rafraichissable {
	
	private Viewport viewport;
	private Modele modele = null;
	public Constantes i18nC;
	
	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);
		// Gestion de l'i18n
		i18nC = GWT.create(Constantes.class);
		// Création du Modèle qui s'enregistre lui même dans le Registre
		modele = new Modele();
	    // Création de l'utilisateur courrant
		Registry.register(RegistreId.UTILISATEUR_COURANT, new Utilisateur(null, false));
		this.connecterUtilisateur(null, null);
	    // Création du projet courrant
		Registry.register(RegistreId.PROJET_COURANT, new Projet());
		
		// Création du Viewport qui contient la disposition globale de l'application
		viewport = new Viewport();
		viewport.setLayout(new BorderLayout());
		
		// Création des différents panneaux
	    creerPanneauNord();
	    creerPanneauOuest();
	    creerPanneauCentral();
	    creerPanneauSud();
 
		// Registry utile car présent partout!
		Registry.register(RegistreId.VIEWPORT, viewport);
		Registry.register(RegistreId.PANNEAU_OUEST, panneauOuest);
		Registry.register(RegistreId.PANNEAU_CENTRE, panneauCentre);
		Registry.register(RegistreId.PANNEAU_SUD, panneauSud);
 
		// Chargement du menu
		chargeMenuApplication();
		
		// Retour à GWT du Viewport une fois constuit
		RootPanel.get().add(viewport);
		
		masquerPopinChargement(); 
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												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() {
		System.out.println(panneauCentre);
		panneauCentre.layout();
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION du MENU
	//+----------------------------------------------------------------------------------------------------------------+
	
	public void chargeMenuApplication() {
		((MenuVue) Registry.get(RegistreId.PANNEAU_OUEST)).chargerMenus();		
	}
 
	public void clicMenu(String codeMenuClique) {
		activerChargement(codeMenuClique);
		panneauCentre.removeAll();
		if (codeMenuClique.equals(MenuApplicationId.STRUCTURE)) {
			modele.selectionnerStructure(panneauCentre, getProjetId(), null);
		} else if (codeMenuClique.equals(MenuApplicationId.PUBLICATION)) {
			modele.selectionnerPublications(panneauCentre);
		} else if (codeMenuClique.equals(MenuApplicationId.PERSONNE)) { 
			modele.selectionnerPersonne(panneauCentre, null, getProjetId(), null);
		} else if (codeMenuClique.equals(MenuApplicationId.COLLECTION)) { 
			selectionnerCollection(panneauCentre, null);
		} 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 afficherListeValeurs(ValeurListe nouvelleDonnees) {
		if (panneauCentre.getId().equals(ComposantId.PANNEAU_STRUCTURE_FORM)) {
			((StructureForm) panneauCentre.getItem(0)).rafraichir(nouvelleDonnees);
		} else {
			GWT.log("Aucun panneau trouvé pour afficher la liste de valeur", null);
		}
	}
 
	public void obtenirListeValeurEtRafraichir(Rafraichissable vue, String listeId)	{
		modele.obtenirListeValeurs(vue, ((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 vue)	{
		modele.selectionnerProjets(vue);
	}
	
	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);
			//FIXME Le rafraichissement du panneau ne se fait pas!
		} else if (contenuPanneauCentre instanceof StructureVue)	{
			modele.obtenirListeStructures(contenuPanneauCentre, getProjetId());
		}
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES STRUCTURES
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void afficherListeStructures(StructureListe structuresACharger) {
		// TODO : créer dès l'initialisation de l'application InsitutionVue et la cacher
		StructureVue institutionVue = new StructureVue(this);
		panneauCentre.add(institutionVue);
		panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_LISTE);
		contenuPanneauCentre = institutionVue;
		institutionVue.rafraichir(structuresACharger);
	}
	
	public void clicListeStructure(Structure structure) {
		contenuPanneauCentre.rafraichir(structure);
		if (structure.getPersonnel() == null) {
			selectionnerStructureAPersonne(contenuPanneauCentre, structure.getId(), StructureAPersonne.ROLE_EQUIPE);
		} else {
			GWT.log("OK personnel déjà chargé", null);
		}
	}
 
	public void clicAjouterStructure() {
		panneauCentre.removeAll();
		StructureForm structureForm = new StructureForm(this, StructureForm.MODE_AJOUTER);
		panneauCentre.add(structureForm);
		panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_FORM);
		panneauCentre.layout();
	}
	
	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) {
			panneauCentre.removeAll();
			StructureForm structureForm = new StructureForm(this, StructureForm.MODE_MODIFIER);
			panneauCentre.add(structureForm);
			panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_FORM);
			
			selectionnerStructure(structureForm, structureSelection.get(0).getId());
			selectionnerStructureAPersonne(structureForm, structureSelection.get(0).getId(), StructureAPersonne.ROLE_EQUIPE);
			
			panneauCentre.layout();
		} 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 message = "Êtes vous sur de vouloir supprimer les structures sélectionnées ?";
			if (structureSelection.size() == 1) {
				message = "Êtes vous sur de vouloir supprimer la structure sélectionnée ?";
			}
			
			final Listener<WindowEvent> suppressionEcouteur = new Listener<WindowEvent>() { 
				public void handleEvent(WindowEvent ce) {  
					Dialog dialog = (Dialog) ce.component;
					Button btn = dialog.getButtonPressed();  
 
					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("Supprimer une structure", 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) {
		CollectionVue collectionVue = new CollectionVue(this);
		panneauCentre.add(collectionVue);
		panneauCentre.setId(ComposantId.PANNEAU_COLLECTION_LISTE);
		contenuPanneauCentre = collectionVue;
		collectionVue.rafraichir(collectionsACharger);
	}
	
	public void clicListeCollection(Collection collectionCliquee) {
		contenuPanneauCentre.rafraichir(collectionCliquee);
	}
	
	public void clicAjouterCollection() {
		// TODO Auto-generated method stub
		
	}
 
	public void clicModifierCollection(List<Collection> selection) {
		// TODO Auto-generated method stub
		
	}
 
	public void clicSupprimerCollection(CollectionListeVue collectionListeVue, List<Collection> collectionsASupprimer) {
		// TODO Auto-generated method stub
		
	}
 
	public void selectionnerCollection(Rafraichissable vueARafraichir, String structureId) {
		modele.selectionnerCollection(vueARafraichir, getProjetId(), structureId);
	}
	
	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)	{
		PersonneVue personneVue = new PersonneVue();
		contenuPanneauCentre = personneVue;
		panneauCentre.add(personneVue);
		
		contenuPanneauCentre.rafraichir(personnesACharger);
		//contenuPanneauCentre.layout();
	}
 
	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);
			
			panneauCentre.layout();			
		}
	}
	
	public void selectionnerPersonne(Rafraichissable vue, Personne personne)	{
		modele.selectionnerPersonne(vue, personne.getId(), null, null);
	}
	
	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<WindowEvent> listenerSuppression = new Listener<WindowEvent>() { 
				public void handleEvent(WindowEvent ce) {
					Dialog dialog = (Dialog) ce.component;
					Button btn = dialog.getButtonPressed();  
 
					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 vue, String projetId, String nomComplet) {
		modele.selectionnerPersonne(vue, null, projetId, nomComplet);
	}
	
	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) {
		PublicationVue publicationVue = new PublicationVue() ;
		panneauCentre.removeAll();
		panneauCentre.add(publicationVue);
		contenuPanneauCentre = publicationVue;
		publicationVue.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<WindowEvent> listenerSuppression = new Listener<WindowEvent>() { 
				public void handleEvent(WindowEvent ce) {  
					Dialog dialog = (Dialog) ce.component;
				    Button btn = dialog.getButtonPressed();  
				    	   
				    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);
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												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)/trunk/src/org/tela_botanica/client/Mediateur.java @ 1333 – Rev 453 → 454

Rev 453		Rev 454
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.interfaces.Rafraichissable;`	10	`import org.tela_botanica.client.interfaces.Rafraichissable;`
11	`import org.tela_botanica.client.modeles.Collection;`	11	`import org.tela_botanica.client.modeles.Collection;`
12	`import org.tela_botanica.client.modeles.CollectionListe;`	12	`import org.tela_botanica.client.modeles.CollectionListe;`
13	`import org.tela_botanica.client.modeles.Configuration;`	13	`import org.tela_botanica.client.modeles.Configuration;`
14	`import org.tela_botanica.client.modeles.Information;`	14	`import org.tela_botanica.client.modeles.Information;`
15	`import org.tela_botanica.client.modeles.MenuApplicationId;`	15	`import org.tela_botanica.client.modeles.MenuApplicationId;`
16	`import org.tela_botanica.client.modeles.Personne;`	16	`import org.tela_botanica.client.modeles.Personne;`
17	`import org.tela_botanica.client.modeles.PersonneListe;`	17	`import org.tela_botanica.client.modeles.PersonneListe;`
18	`import org.tela_botanica.client.modeles.Projet;`	18	`import org.tela_botanica.client.modeles.Projet;`
19	`import org.tela_botanica.client.modeles.ProjetListe;`	19	`import org.tela_botanica.client.modeles.ProjetListe;`
20	`import org.tela_botanica.client.modeles.Publication;`	20	`import org.tela_botanica.client.modeles.Publication;`
21	`import org.tela_botanica.client.modeles.PublicationListe;`	21	`import org.tela_botanica.client.modeles.PublicationListe;`
22	`import org.tela_botanica.client.modeles.Structure;`	22	`import org.tela_botanica.client.modeles.Structure;`
23	`import org.tela_botanica.client.modeles.StructureAPersonne;`	23	`import org.tela_botanica.client.modeles.StructureAPersonne;`
24	`import org.tela_botanica.client.modeles.StructureAPersonneListe;`	24	`import org.tela_botanica.client.modeles.StructureAPersonneListe;`
25	`import org.tela_botanica.client.modeles.StructureConservation;`	25	`import org.tela_botanica.client.modeles.StructureConservation;`
26	`import org.tela_botanica.client.modeles.StructureListe;`	26	`import org.tela_botanica.client.modeles.StructureListe;`
27	`import org.tela_botanica.client.modeles.StructureValorisation;`	27	`import org.tela_botanica.client.modeles.StructureValorisation;`
28	`import org.tela_botanica.client.modeles.Utilisateur;`	28	`import org.tela_botanica.client.modeles.Utilisateur;`
29	`import org.tela_botanica.client.modeles.ValeurListe;`	29	`import org.tela_botanica.client.modeles.ValeurListe;`
30	`import org.tela_botanica.client.vues.CollectionListeVue;`	30	`import org.tela_botanica.client.vues.CollectionListeVue;`
31	`import org.tela_botanica.client.vues.CollectionVue;`	31	`import org.tela_botanica.client.vues.CollectionVue;`
32	`import org.tela_botanica.client.vues.ContenuVue;`	32	`import org.tela_botanica.client.vues.ContenuVue;`
33	`import org.tela_botanica.client.vues.EnteteVue;`	33	`import org.tela_botanica.client.vues.EnteteVue;`
34	`import org.tela_botanica.client.vues.PersonneForm;`	34	`import org.tela_botanica.client.vues.PersonneForm;`
35	`import org.tela_botanica.client.vues.PublicationForm;`	35	`import org.tela_botanica.client.vues.PublicationForm;`
36	`import org.tela_botanica.client.vues.StructureForm;`	36	`import org.tela_botanica.client.vues.StructureForm;`
37	`import org.tela_botanica.client.vues.PersonneDetailVue;`	37	`import org.tela_botanica.client.vues.PersonneDetailVue;`
38	`import org.tela_botanica.client.vues.PersonneVue;`	38	`import org.tela_botanica.client.vues.PersonneVue;`
39	`import org.tela_botanica.client.vues.PopupChargement;`	39	`import org.tela_botanica.client.vues.PopupChargement;`
40	`import org.tela_botanica.client.vues.PublicationDetailVue;`	40	`import org.tela_botanica.client.vues.PublicationDetailVue;`