| New file |
|---|
| 0,0 → 1,1637 |
|---|
| 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.InfoLogger; |
| import org.tela_botanica.client.composants.LicenceFenetre; |
| import org.tela_botanica.client.composants.AproposFenetre; |
| import org.tela_botanica.client.configuration.APropos; |
| import org.tela_botanica.client.configuration.Configuration; |
| 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.Information; |
| import org.tela_botanica.client.modeles.MenuApplicationId; |
| import org.tela_botanica.client.modeles.Utilisateur; |
| import org.tela_botanica.client.modeles.Valeur; |
| import org.tela_botanica.client.modeles.ValeurListe; |
| import org.tela_botanica.client.modeles.collection.Collection; |
| import org.tela_botanica.client.modeles.collection.CollectionACommentaire; |
| import org.tela_botanica.client.modeles.collection.CollectionACommentaireAsyncDao; |
| import org.tela_botanica.client.modeles.collection.CollectionACommentaireListe; |
| import org.tela_botanica.client.modeles.collection.CollectionAPersonne; |
| import org.tela_botanica.client.modeles.collection.CollectionAPersonneListe; |
| import org.tela_botanica.client.modeles.collection.CollectionAPublication; |
| import org.tela_botanica.client.modeles.collection.CollectionAPublicationListe; |
| import org.tela_botanica.client.modeles.collection.CollectionListe; |
| import org.tela_botanica.client.modeles.commentaire.Commentaire; |
| import org.tela_botanica.client.modeles.commentaire.CommentaireListe; |
| import org.tela_botanica.client.modeles.personne.Personne; |
| import org.tela_botanica.client.modeles.personne.PersonneListe; |
| import org.tela_botanica.client.modeles.projet.Projet; |
| import org.tela_botanica.client.modeles.projet.ProjetListe; |
| import org.tela_botanica.client.modeles.publication.Publication; |
| import org.tela_botanica.client.modeles.publication.PublicationAPersonne; |
| import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe; |
| import org.tela_botanica.client.modeles.publication.PublicationListe; |
| import org.tela_botanica.client.modeles.structure.Structure; |
| import org.tela_botanica.client.modeles.structure.StructureAPersonne; |
| import org.tela_botanica.client.modeles.structure.StructureAPersonneListe; |
| import org.tela_botanica.client.modeles.structure.StructureConservation; |
| import org.tela_botanica.client.modeles.structure.StructureListe; |
| import org.tela_botanica.client.modeles.structure.StructureValorisation; |
| import org.tela_botanica.client.synchronisation.Sequenceur; |
| 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.FenetreJournal; |
| import org.tela_botanica.client.vues.NavigationVue; |
| import org.tela_botanica.client.vues.PopupChargement; |
| import org.tela_botanica.client.vues.StatutVue; |
| import org.tela_botanica.client.vues.MenuVue; |
| import org.tela_botanica.client.vues.accueil.AccueilVue; |
| import org.tela_botanica.client.vues.collection.CollectionForm; |
| import org.tela_botanica.client.vues.collection.CollectionListeVue; |
| import org.tela_botanica.client.vues.collection.CollectionVue; |
| import org.tela_botanica.client.vues.commentaire.CommentaireForm; |
| import org.tela_botanica.client.vues.commentaire.CommentaireVue; |
| import org.tela_botanica.client.vues.personne.PersonneForm; |
| import org.tela_botanica.client.vues.personne.PersonneVue; |
| import org.tela_botanica.client.vues.projet.ProjetForm; |
| import org.tela_botanica.client.vues.projet.ProjetVue; |
| import org.tela_botanica.client.vues.publication.PublicationForm; |
| import org.tela_botanica.client.vues.publication.PublicationVue; |
| import org.tela_botanica.client.vues.structure.StructureForm; |
| import org.tela_botanica.client.vues.structure.StructureVue; |
| |
| import com.extjs.gxt.ui.client.Registry; |
| import com.extjs.gxt.ui.client.Style.LayoutRegion; |
| import com.extjs.gxt.ui.client.data.DataProxy; |
| 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.Component; |
| 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.gargoylesoftware.htmlunit.AlertHandler; |
| 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(); |
| public static final boolean DEBUG = true; |
| |
| private EnteteVue panneauNord = null; |
| private NavigationVue panneauOuest = null; |
| private ContenuVue panneauCentre = null; |
| private StatutVue panneauSud = null; |
| private FenetreJournal fenetreJournal = null; |
| |
| private IdentificationFenetre fenetreIdentification = null; |
| private int nbElements = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); |
| |
| public Mediateur() { |
| // Enregistrement du Médiateur dans le Registre |
| Registry.register(RegistreId.MEDIATEUR, this); |
| |
| //Initialisation du Registre |
| initialiserRegistre(); |
| |
| // 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()); |
| |
| // Création des différents panneaux |
| creerPanneauNord(); |
| creerPanneauOuest(); |
| creerPanneauCentral(); |
| creerPanneauSud(); |
| fenetreJournal = new FenetreJournal(this); |
| |
| // 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() { |
| APropos apropos = new APropos(); |
| |
| Registry.register(RegistreId.APPLI_NOM, apropos.getAppliNom()); |
| Registry.register(RegistreId.APPLI_CODE, apropos.getAppliCode()); |
| Registry.register(RegistreId.APPLI_VERSION, apropos.getAppliVersionCode()); |
| Registry.register(RegistreId.APPLI_VERSION_NOM, apropos.getAppliVersionNom()); |
| |
| Registry.register(RegistreId.APPLI_DEVELOPPEURS, apropos.getDeveloppeurs()); |
| Registry.register(RegistreId.APPLI_TRADUCTEURS, apropos.getTraducteurs()); |
| Registry.register(RegistreId.APPLI_LICENCE, apropos.getLicence()); |
| Registry.register(RegistreId.APPLI_REVISION, apropos.getRevisionGlobale()); |
| Registry.register(RegistreId.APPLI_COMPILATION_JAVA_VERSION, apropos.getVersionJavaCompilation()); |
| Registry.register(RegistreId.APPLI_COMPILATION_DATE_HEURE, apropos.getDateHeureCompilation()); |
| |
| Registry.register(RegistreId.CONFIG, new Configuration()); |
| Registry.register(RegistreId.POPUP_CHARGEMENT, new PopupChargement(this)); |
| Registry.register(RegistreId.UTILISATEUR_COURANT, new Utilisateur()); |
| 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 NavigationVue(this); |
| |
| BorderLayoutData regionOuest = new BorderLayoutData(LayoutRegion.WEST, 241); |
| regionOuest.setSplit(true); |
| regionOuest.setCollapsible(true); |
| regionOuest.setMargins(new Margins(5)); |
| |
| viewport.add(panneauOuest, regionOuest); |
| } |
| |
| public String getFiltreProjet() { |
| return panneauOuest.getFiltre().getProjet(); |
| } |
| |
| 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(); |
| } |
| |
| public Rafraichissable obtenirFenetreJournal() { |
| return this.fenetreJournal; |
| } |
| |
| public void ouvrirFenetreJournal() { |
| fenetreJournal.show(); |
| } |
| |
| public StatutVue obtenirPanneauSud() { |
| return this.panneauSud; |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION du MENU |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void clicMenu(String codeMenuClique) { |
| |
| activerChargement(codeMenuClique); |
| panneauOuest.getMenu().selectionMenu(codeMenuClique); |
| |
| if (codeMenuClique.equals(MenuApplicationId.ACCUEIL)) { |
| afficherAccueil(); |
| } else if (codeMenuClique.equals(MenuApplicationId.PROJET)) { |
| selectionnerProjet(panneauCentre, null, null); |
| } else if (codeMenuClique.equals(MenuApplicationId.STRUCTURE)) { |
| selectionnerStructure(panneauCentre, null, null); |
| } else if (codeMenuClique.equals(MenuApplicationId.COLLECTION)) { |
| selectionnerCollection(panneauCentre, null, null, null); |
| } else if (codeMenuClique.equals(MenuApplicationId.PERSONNE)) { |
| selectionnerPersonne(panneauCentre, null, getProjetId(), null); |
| } else if (codeMenuClique.equals(MenuApplicationId.PUBLICATION)) { |
| selectionnerPublication(panneauCentre, null, null); |
| } else if (codeMenuClique.equals(MenuApplicationId.COMMENTAIRE)) { |
| selectionnerCommentaire(panneauCentre, null, null); |
| } else { |
| GWT.log(i18nM.nonImplemente(codeMenuClique), null); |
| } |
| panneauCentre.layout(); |
| } |
| |
| public void activerChargement(String message) { |
| afficherPopinChargement(); |
| panneauCentre.disable(); |
| panneauSud.showBusy(i18nC.chargement()+" "+message); |
| } |
| |
| public void desactiverChargement() { |
| masquerPopinChargement(); |
| panneauCentre.enable(); |
| 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() { |
| AproposFenetre parametresFenetre = new AproposFenetre(); |
| parametresFenetre.show(); |
| } |
| |
| public void ouvrirIdentification() { |
| fenetreIdentification = new IdentificationFenetre(this); |
| fenetreIdentification.show(); |
| } |
| |
| public void ouvrirUrlExterne(String id) { |
| if (id.equals(ComposantId.MENU_CEL)) { |
| Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getUrl("cel"), "Carnet en ligne", ""); |
| } else if (id.equals(ComposantId.MENU_BEL)) { |
| Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getUrl("cel"), "Biblio en ligne", ""); |
| } else if (id.equals(ComposantId.MENU_BOGUE)) { |
| Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getUrl("bogue"), "Bogue", ""); |
| } else if (id.equals(ComposantId.MENU_COMMENTAIRE)) { |
| Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getUrl("commentaire"), "Commentaire", ""); |
| } |
| } |
| |
| public void afficherFenetreLicence(IdentificationFenetre vue) { |
| LicenceFenetre lf = new LicenceFenetre(vue); |
| } |
| |
| public void accepterLicence(Rafraichissable vue) { |
| modele.accepterLicence(vue); |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // 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 Utilisateur getUtilisateur() { |
| Utilisateur utilisateurCourant = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT); |
| return utilisateurCourant; |
| } |
| |
| public void connecterUtilisateur(String login, String mdp) { |
| modele.connecterUtilisateur(this, login, mdp); |
| } |
| |
| public void deconnecterUtilisateur() { |
| modele.deconnecterUtilisateur(this); |
| } |
| |
| public void repandreEtatIdentification(Utilisateur utilisateur) { |
| // Mise à jour du registre |
| Registry.register(RegistreId.UTILISATEUR_COURANT, utilisateur); |
| // Propagation de l'information de mise à jour de l'utilisateur |
| repandreInfoMiseAJourUtilisateur(); |
| } |
| |
| public void repandreInfoMiseAJourUtilisateur() { |
| // 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.isVisible()) { |
| fenetreIdentification.rafraichir(info); |
| } |
| |
| // Rafraichissement du panneau Nord |
| panneauNord.rafraichir(info); |
| |
| // Rafraichissement du panneau Centre |
| if (panneauCentre != null) { |
| panneauCentre.rafraichir(info); |
| } |
| } |
| |
| public void modifierUtilisateur() { |
| Utilisateur utilisateurCourant = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT); |
| panneauNord.rafraichir(utilisateurCourant); |
| modele.modifierUtilisateur(this, utilisateurCourant); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DES VALEURS ET LISTES |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| /** Cette méthode est un "wrapper" **/ |
| public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, String listeId, Sequenceur sequenceur) { |
| obtenirListeValeurEtRafraichir(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), sequenceur); |
| } |
| |
| public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, int listeId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner ValeurListe"); |
| Integer numeroSequence = null; |
| if (sequenceur != null) { |
| numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.obtenirListeValeurs(vueARafraichir, listeId, numeroSequence); |
| } |
| |
| public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, String nomListe, boolean pagination, String recherche, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner ValeurListe"); |
| Integer numeroSequence = null; |
| if (sequenceur != null) { |
| numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.obtenirListeValeurs(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(nomListe), pagination, recherche, start, nbElements, numeroSequence); |
| } |
| |
| public void obtenirValeurEtRafraichir(Rafraichissable vueARafraichir, String listeId, String identifiantValeur, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner ValeurListe"); |
| Integer numeroSequence = null; |
| if (sequenceur != null) { |
| numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.obtenirValeur(vueARafraichir, "identifiant", ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), identifiantValeur, numeroSequence); |
| } |
| |
| public void obtenirListeRegionsEtRafraichir(Rafraichissable vueARafraichir, String strListeId, String strPays) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner obtenirListeRegions"); |
| modele.obtenirListeRegion(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(strListeId), strPays+".__"); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION des APPLETS de l'ACCUEIL |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void afficherAccueil() { |
| if (!(panneauCentre.getContenu() instanceof AccueilVue)) { |
| panneauCentre.removeAll(); |
| panneauCentre.add(new AccueilVue(this)); |
| } |
| else { |
| desactiverChargement(); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION des PROJETS |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void afficherFormProjet(String projetId) { |
| panneauCentre.removeAll(); |
| ProjetForm projetForm = new ProjetForm(this, projetId); |
| panneauCentre.add(projetForm); |
| |
| panneauCentre.layout(); |
| } |
| |
| public void afficherListeProjets(ProjetListe projetsACharger) { |
| if (!(panneauCentre.getContenu() instanceof ProjetVue)) { |
| panneauCentre.removeAll(); |
| panneauCentre.add(new ProjetVue(this)); |
| panneauCentre.setId(ComposantId.PANNEAU_PROJET_LISTE); |
| panneauCentre.layout(); |
| } |
| |
| panneauCentre.getContenu().rafraichir(projetsACharger); |
| mettreFiltreAJour(projetsACharger); |
| } |
| |
| public void mettreFiltreAJour(ProjetListe projetsACharger) { |
| panneauOuest.getFiltre().rafraichir(projetsACharger); |
| } |
| |
| public void mettreFiltreAJour(List<Projet> projetsACharger) { |
| panneauOuest.getFiltre().rafraichir(projetsACharger); |
| } |
| |
| public void clicListeProjet(Projet projet) { |
| panneauCentre.getContenu().rafraichir(projet); |
| } |
| |
| public void clicSupprimerProjet(final List<Projet> projetListe) { |
| if (projetListe.size() <= 0) { |
| MessageBox.alert("Attention", "Vous devez sélectionner un projet", null); |
| } else { |
| String message = "Voulez-vous vraiment supprimer ces projets ?"; |
| if (projetListe.size() == 1) { |
| message = "Voulez-vous vraiment supprimer ce projet ?"; |
| } |
| |
| 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.supprimerProjet(panneauCentre.getContenu(), projetListe); |
| } |
| } |
| }; |
| |
| MessageBox.confirm("Supprimer un projet", message, listenerSuppression); |
| } |
| |
| } |
| |
| public void clicModifierProjet(List<Projet> projetsSelectionnes) { |
| if (projetsSelectionnes.size() == 0) { |
| InfoLogger.display("Information", "Veuillez sélectionner un projet."); |
| } else if (projetsSelectionnes.size() > 1) { |
| InfoLogger.display("Information", "Veuillez sélectionner un seul projet à la fois."); |
| } else if (projetsSelectionnes.size() == 1) { |
| afficherFormProjet(projetsSelectionnes.get(0).getId()); |
| } else { |
| InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierProjet() du Médiateur."); |
| } |
| } |
| |
| public void clicAjouterProjet() { |
| afficherFormProjet(null); |
| } |
| |
| /**************************************************************************************************** |
| /** selectionnerProjet(Rafraichissable vueARafraichir, String recherche, int start, int nbElements) |
| /**************************************************************************************************** |
| * Action : |
| * -------- |
| * - Récupère un nombre défini de projets en s'aidant du nom partiel ou complet du projet. |
| * |
| * Description des paramètres : |
| * ---------------------------- |
| * - 'vueARafraichir' référence l'objet à mettre à jour après réception des données. |
| * - 'recherche' est une chaîne de caractères représentant tout ou partie du nom d'un projet. |
| * Si la chaîne est vide, alors tous les projets sont recherchés. |
| * - 'start' et 'nbElements' sont les paramètres indispensables à la pagination. 'start' |
| * est le paramètre qui décrit le numéro du tuple de départ et 'nbElements' le nombre |
| * d'éléments à collecter. |
| * |
| * Préconditions : |
| * --------------- |
| * - 'vueARafraichir' doit être non NULL et référencer un objet implémentant l'interface |
| * 'Rafraichissable' |
| * - 'recherche' doit être non NULL. |
| * - 'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro. |
| * |
| *****************************************************************************************************/ |
| public void selectionnerProjet(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Projet"); |
| Integer numeroSequence = null; |
| if (sequenceur != null) { |
| numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerProjet(vueARafraichir, recherche, start, nbElements, numeroSequence); |
| } |
| |
| /** Cette méthode est un "wrapper" **/ |
| public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) { |
| selectionnerProjet(vueARafraichir, projetId, null, 0, this.nbElements, sequenceur); |
| } |
| |
| public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, String nom, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Projet"); |
| Integer numeroSequence = null; |
| if (sequenceur != null) { |
| numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerProjet(vueARafraichir, projetId, nom, start, nbElements, numeroSequence); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterProjet(Rafraichissable vueARafraichir, Projet projetCollecte) { |
| modele.ajouterProjet(vueARafraichir, projetCollecte); |
| } |
| |
| /** MODIFIER **/ |
| public void modifierProjet(Rafraichissable vueARafraichir, Projet projetCollecte) { |
| modele.modifierProjet(vueARafraichir, projetCollecte); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // SELECTION : projet |
| /** |
| * 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; |
| } |
| |
| public void selectionnerProjetCourant(Projet projetSelectionne) { |
| Registry.register(RegistreId.PROJET_COURANT, projetSelectionne); |
| if (panneauCentre.getContenu() instanceof AccueilVue) { |
| desactiverChargement(); |
| } else if (panneauCentre.getContenu() instanceof ProjetVue) { |
| selectionnerProjet(panneauCentre.getContenu(), null, null); |
| } else if (panneauCentre.getContenu() instanceof StructureVue) { |
| selectionnerStructure(panneauCentre.getContenu(), null, null); |
| } else if (panneauCentre.getContenu() instanceof CollectionVue) { |
| selectionnerCollection(panneauCentre.getContenu(), null, null, null); |
| } else if (panneauCentre.getContenu() instanceof PersonneVue) { |
| selectionnerPersonne(panneauCentre.getContenu(), null, getProjetId(), null); |
| } else if (panneauCentre.getContenu() instanceof PublicationVue) { |
| selectionnerPublication(panneauCentre.getContenu(), null, null); |
| } else if (panneauCentre.getContenu() instanceof CommentaireVue) { |
| selectionnerCommentaire(panneauCentre.getContenu(), null, null); |
| } |
| } |
| |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DES STRUCTURES |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void afficherListeStructures(StructureListe structuresACharger) { |
| if (!(panneauCentre.getContenu() instanceof StructureVue)) { |
| panneauCentre.removeAll(); |
| panneauCentre.add(new StructureVue(this)); |
| } |
| panneauCentre.getContenu().rafraichir(structuresACharger); |
| } |
| |
| public void afficherFormStructure(String structureId) { |
| String mode = Formulaire.MODE_AJOUTER; |
| if (structureId != null) { |
| mode = Formulaire.MODE_MODIFIER; |
| } |
| |
| panneauCentre.removeAll(); |
| Sequenceur sequenceur = new Sequenceur(); |
| StructureForm structureForm = new StructureForm(this, mode, sequenceur); |
| panneauCentre.add(structureForm); |
| |
| if (mode.equals(Formulaire.MODE_MODIFIER)) { |
| selectionnerStructure(structureForm, structureId, sequenceur); |
| selectionnerStructureAPersonne(structureForm, structureId, StructureAPersonne.ROLE_EQUIPE, sequenceur); |
| } |
| |
| panneauCentre.layout(); |
| } |
| |
| public void clicListeStructure(Structure structure) { |
| panneauCentre.getContenu().rafraichir(structure); |
| if (structure != null && structure.getPersonnel() == null) { |
| selectionnerStructureAPersonne(panneauCentre.getContenu(), structure.getId(), StructureAPersonne.ROLE_EQUIPE, null); |
| } |
| } |
| |
| public void clicAjouterStructure() { |
| afficherFormStructure(null); |
| } |
| |
| public void clicModifierStructure(List<Structure> structureSelection) { |
| if (structureSelection.size() == 0) { |
| InfoLogger.display("Information", "Veuillez sélectionner une structure."); |
| } else if (structureSelection.size() > 1) { |
| InfoLogger.display("Information", "Veuillez sélectionner une seule structure à la fois."); |
| } else if (structureSelection.size() == 1) { |
| afficherFormStructure(structureSelection.get(0).getId()); |
| } else { |
| InfoLogger.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) { |
| InfoLogger.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 { |
| InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerStructure() du Médiateur."); |
| } |
| } |
| |
| /**************************************************************************************************** |
| /** selectionnerStructure(Rafraichissable vueARafraichir, String recherche, int start, int nbElements) |
| /**************************************************************************************************** |
| * Action : |
| * -------- |
| * - Récupère un nombre défini de structures en s'aidant du nom partiel ou complet de la structure. |
| * |
| * Description des paramètres : |
| * ---------------------------- |
| * - 'vueARafraichir' référence l'objet à mettre à jour après réception des données. |
| * - 'recherche' est une chaîne de caractères représentant tout ou partie du nom d'une structure. |
| * Si la chaîne est vide, alors toutes les structures sont recherchées. |
| * - 'start' et 'nbElements' sont les paramètres indispensables à la pagination. 'start' |
| * est le paramètre qui décrit le numéro du tuple de départ et 'nbElements' le nombre |
| * d'éléments à collecter. |
| * |
| * Préconditions : |
| * --------------- |
| * - 'vueARafraichir' doit être non NULL et référencer un objet implémentant l'interface |
| * 'Rafraichissable' |
| * - 'recherche' doit être non NULL. |
| * - 'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro. |
| * |
| *****************************************************************************************************/ |
| public void selectionnerStructure(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Structure"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerStructure(vueARafraichir, recherche, start, nbElements, seqId); |
| } |
| |
| public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Structure"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerStructure(vueARafraichir, getProjetId(), structureId, null, 0, nbElements, seqId); |
| } |
| |
| public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, String projetId, String nom, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Structure"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerStructure(vueARafraichir, getProjetId(), structureId, nom, start, nbElements, seqId); |
| } |
| |
| public void selectionnerStructureParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Structure"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerStructure(vueARafraichir, projetId, null, null, 0, -1, seqId); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterStructure(Rafraichissable vueARafraichir, Structure structure, StructureConservation conservation, StructureValorisation valorisation) { |
| modele.ajouterStructure(vueARafraichir, structure, conservation, valorisation); |
| } |
| |
| /** MODIFIER **/ |
| public void modifierStructure(Rafraichissable vueARafraichir, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) { |
| modele.modifierStructure(vueARafraichir, structureId, structure, conservation, valorisation); |
| } |
| |
| /** SUPPRIMER **/ |
| public void supprimerStructure(Rafraichissable vueARafraichir, String IdentifiantsStructureSepareParVirgule) { |
| modele.supprimerStructure(vueARafraichir, IdentifiantsStructureSepareParVirgule); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION de la relation STRUCTURE A PERSONNE |
| public void selectionnerStructureAPersonne(Rafraichissable vueARafraichir, String structureId, String roleId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner StructureAPersonne"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerStructureAPersonne(vueARafraichir, structureId, roleId, seqId); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterStructureAPersonne(Rafraichissable vueARafraichir, String structureId, StructureAPersonneListe personnelAjoute) { |
| if (personnelAjoute != null && personnelAjoute.size() > 0) { |
| for (Iterator<String> it = personnelAjoute.keySet().iterator(); it.hasNext();) { |
| modele.ajouterStructureAPersonne(vueARafraichir, structureId, (StructureAPersonne) personnelAjoute.get(it.next())); |
| } |
| } |
| } |
| |
| /** MODIFIER **/ |
| public void modifierStructureAPersonne(Rafraichissable vueARafraichir, StructureAPersonneListe personnelModifie) { |
| if (personnelModifie != null && personnelModifie.size() > 0) { |
| for (Iterator<String> it = personnelModifie.keySet().iterator(); it.hasNext();) { |
| modele.modifierStructureAPersonne(vueARafraichir, (StructureAPersonne) personnelModifie.get(it.next())); |
| } |
| } |
| } |
| |
| /** SUPPRIMER **/ |
| public void supprimerStructureAPersonne(Rafraichissable vueARafraichir, StructureAPersonneListe personnelSupprime) { |
| if (personnelSupprime != null && personnelSupprime.size() > 0) { |
| String idStructureAPersonneSepareParVirgule = "" ; |
| Iterator<String> it = personnelSupprime.keySet().iterator(); |
| while (it.hasNext()) { |
| idStructureAPersonneSepareParVirgule += personnelSupprime.get(it.next()).getId(); |
| idStructureAPersonneSepareParVirgule += (it.hasNext()) ? "," : ""; |
| } |
| supprimerStructureAPersonne(vueARafraichir, idStructureAPersonneSepareParVirgule); |
| } |
| } |
| |
| public void supprimerStructureAPersonne(Rafraichissable vueARafraichir, String idStructureAPersonneSeparesParVirgule) { |
| modele.supprimerStructureAPersonne(vueARafraichir, idStructureAPersonneSeparesParVirgule); |
| } |
| |
| public void supprimerStructureAPersonne(final Rafraichissable vueARafraichir, final List<Structure> structuresListe) { |
| if (structuresListe.size() != 0) { |
| String idStructureSepareParVirgule = "" ; |
| Iterator<Structure> it = structuresListe.iterator(); |
| while (it.hasNext()) { |
| Structure structure = it.next(); |
| idStructureSepareParVirgule += structure.getId(); |
| idStructureSepareParVirgule += it.hasNext() ? "," : ""; |
| } |
| supprimerStructureAPersonne(vueARafraichir, idStructureSepareParVirgule); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION des COLLECTIONS |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void afficherListeCollections(CollectionListe collectionsACharger) { |
| if (!(panneauCentre.getContenu() instanceof CollectionVue)) { |
| panneauCentre.removeAll(); |
| panneauCentre.add(new CollectionVue(this)); |
| } |
| |
| panneauCentre.getContenu().rafraichir(collectionsACharger); |
| } |
| |
| public void afficherFormCollection(String collectionId) { |
| panneauCentre.removeAll(); |
| CollectionForm collectionForm = new CollectionForm(this, collectionId); |
| panneauCentre.add(collectionForm); |
| |
| panneauCentre.layout(); |
| } |
| |
| public void clicListeCollection(Collection collectionCliquee) { |
| panneauCentre.getContenu().rafraichir(collectionCliquee); |
| if (collectionCliquee != null) { |
| selectionnerCollectionAPersonne(panneauCentre.getContenu(), collectionCliquee.getId(), null, null); |
| selectionnerCollectionAPublication(panneauCentre.getContenu(), collectionCliquee.getId(), null); |
| selectionnerCollectionACommentaire(panneauCentre.getContenu(), collectionCliquee.getId(), null); |
| } |
| } |
| |
| public void clicAjouterCollection() { |
| afficherFormCollection(null); |
| } |
| |
| public void clicModifierCollection(List<Collection> selection) { |
| if (selection.size() == 0) { |
| InfoLogger.display("Information", "Veuillez sélectionner une collection."); |
| } else if (selection.size() > 1) { |
| InfoLogger.display("Information", "Veuillez sélectionner une seule collection à la fois."); |
| } else if (selection.size() == 1) { |
| afficherFormCollection(selection.get(0).getId()); |
| } else { |
| InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierCollection() du Médiateur."); |
| } |
| } |
| |
| public void clicSupprimerCollection(CollectionListeVue collectionListeVue, final List<Collection> collectionsASupprimer) { |
| if (collectionsASupprimer.size() <= 0) { |
| MessageBox.alert("Attention", "Vous devez sélectionner au moins une collection", null); |
| } else { |
| String message = "Voulez-vous vraiment supprimer ces collections ?"; |
| if (collectionsASupprimer.size() == 1) { |
| message = "Voulez-vous vraiment supprimer cette collection ?"; |
| } |
| |
| 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)) { |
| supprimerCollection(panneauCentre.getContenu(), collectionsASupprimer); |
| } |
| } |
| }; |
| |
| MessageBox.confirm("Supprimer une collection", message, listenerSuppression); |
| } |
| } |
| |
| /** Cette méthode est un "wrapper" **/ |
| public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId, String nom, Sequenceur sequenceur) { |
| selectionnerCollection(vueARafraichir, collectionId, nom, 0, nbElements, sequenceur); |
| } |
| |
| public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId, String nom, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Collection"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerCollection(vueARafraichir, getProjetId(), collectionId, nom, start, nbElements, seqId); |
| } |
| |
| public void selectionnerCollectionParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Collection"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerCollection(vueARafraichir, projetId, null, null, 0, -1, seqId); |
| } |
| |
| /**************************************************************************************************** |
| /** selectionnerCollection(Rafraichissable vueARafraichir, String recherche, int start, int nbElements) |
| /**************************************************************************************************** |
| * Action : |
| * -------- |
| * - Récupère un nombre défini de collections en s'aidant du nom partiel ou complet de la collection. |
| * |
| * Description des paramètres : |
| * ---------------------------- |
| * - 'vueARafraichir' référence l'objet à mettre à jour après réception des données. |
| * - 'recherche' est une chaîne de caractères représentant tout ou partie du nom d'une collection. |
| * Si la chaîne est vide, alors toutes les collections sont recherchées. |
| * - 'start' et 'nbElements' sont les paramètres indispensables à la pagination. 'start' |
| * est le paramètre qui décrit le numéro du tuple de départ et 'nbElements' le nombre |
| * d'éléments à collecter. |
| * |
| * Préconditions : |
| * --------------- |
| * - 'vueARafraichir' doit être non NULL et référencer un objet implémentant l'interface |
| * 'Rafraichissable' |
| * - 'recherche' doit être non NULL. |
| * - 'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro. |
| * |
| *****************************************************************************************************/ |
| public void selectionnerCollection(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Collection"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerCollection(vueARafraichir, recherche, start, nbElements, seqId); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterCollection(Rafraichissable vueARafraichir, Collection collection) { |
| modele.ajouterCollection(vueARafraichir, collection); |
| } |
| |
| /** MODIFIER **/ |
| public void modifierCollection(Rafraichissable vueARafraichir, Collection collection) { |
| modele.modifierCollection(vueARafraichir, collection); |
| } |
| |
| /** SUPPRIMER **/ |
| public void supprimerCollection(Rafraichissable vueARafraichir, List<Collection> collectionsListe) { |
| if (collectionsListe != null && collectionsListe.size() > 0) { |
| String idCollectionSeparesParVirgule = "" ; |
| Iterator<Collection> it = collectionsListe.iterator(); |
| while (it.hasNext()) { |
| idCollectionSeparesParVirgule += it.next().getId(); |
| if (it.hasNext()) { |
| idCollectionSeparesParVirgule += ","; |
| } |
| } |
| modele.supprimerCollection(vueARafraichir, idCollectionSeparesParVirgule); |
| modele.supprimerCollectionAPersonne(vueARafraichir, idCollectionSeparesParVirgule); |
| modele.supprimerCollectionAPublication(vueARafraichir, idCollectionSeparesParVirgule); |
| //modele.supprimerCollectionACommentaire(vueARafraichir, idCollectionSeparesParVirgule); |
| } |
| |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION de la relation COLLECTION A PERSONNE |
| |
| public void selectionnerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, String roleId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner CollectionAPersonne"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerCollectionAPersonne(vueARafraichir, collectionId, roleId, seqId); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, CollectionAPersonneListe personnesAjoutees) { |
| if (personnesAjoutees != null && personnesAjoutees.size() > 0) { |
| for (Iterator<String> it = personnesAjoutees.keySet().iterator(); it.hasNext();) { |
| modele.ajouterCollectionAPersonne(vueARafraichir, collectionId, (CollectionAPersonne) personnesAjoutees.get(it.next())); |
| } |
| } |
| } |
| |
| /** MODIFIER **/ |
| public void modifierCollectionAPersonne(Rafraichissable vueARafraichir, CollectionAPersonneListe personnesModifiees) { |
| if (personnesModifiees != null && personnesModifiees.size() > 0) { |
| for (Iterator<String> it = personnesModifiees.keySet().iterator(); it.hasNext();) { |
| modele.modifierCollectionAPersonne(vueARafraichir, (CollectionAPersonne) personnesModifiees.get(it.next())); |
| } |
| } |
| } |
| |
| /** SUPPRIMER **/ |
| public void supprimerCollectionAPersonne(Rafraichissable vueARafraichir, CollectionAPersonneListe personnesSupprimees) { |
| if (personnesSupprimees != null && personnesSupprimees.size() > 0) { |
| String idCollectionAPersonneSeparesParVirgule = "" ; |
| for (Iterator<String> it = personnesSupprimees.keySet().iterator(); it.hasNext();) { |
| idCollectionAPersonneSeparesParVirgule += personnesSupprimees.get(it.next()).getId(); |
| if (it.hasNext()) { |
| idCollectionAPersonneSeparesParVirgule += ","; |
| } |
| } |
| modele.supprimerCollectionAPersonne(vueARafraichir, idCollectionAPersonneSeparesParVirgule); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION de la relation COLLECTION A PUBLICATION |
| |
| public void selectionnerCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner CollectionAPublication"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerCollectionAPublication(vueARafraichir, collectionId, seqId); |
| } |
| |
| public void ajouterCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, CollectionAPublicationListe publicationsAjoutees) { |
| if (publicationsAjoutees != null && publicationsAjoutees.size() > 0) { |
| for (Iterator<String> it = publicationsAjoutees.keySet().iterator(); it.hasNext();) { |
| modele.ajouterCollectionAPublication(vueARafraichir, collectionId, (CollectionAPublication) publicationsAjoutees.get(it.next())); |
| } |
| } |
| } |
| |
| public void modifierCollectionAPublication(Rafraichissable vueARafraichir, CollectionAPublicationListe publicationsModifiees) { |
| if (publicationsModifiees != null && publicationsModifiees.size() > 0) { |
| for (Iterator<String> it = publicationsModifiees.keySet().iterator(); it.hasNext();) { |
| modele.modifierCollectionAPublication(vueARafraichir, (CollectionAPublication) publicationsModifiees.get(it.next())); |
| } |
| } |
| } |
| |
| public void supprimerCollectionAPublication(Rafraichissable vueARafraichir, CollectionAPublicationListe publicationsSupprimees) { |
| if (publicationsSupprimees != null && publicationsSupprimees.size() > 0) { |
| String idCollectionAPublicationSeparesParVirgule = "" ; |
| for (Iterator<String> it = publicationsSupprimees.keySet().iterator(); it.hasNext();) { |
| idCollectionAPublicationSeparesParVirgule += publicationsSupprimees.get(it.next()).getId(); |
| if (it.hasNext()) { |
| idCollectionAPublicationSeparesParVirgule += ","; |
| } |
| } |
| modele.supprimerCollectionAPublication(vueARafraichir, idCollectionAPublicationSeparesParVirgule); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION de la relation COLLECTION A COMMENTAIRE |
| |
| public void selectionnerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner CollectionACommentaire"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerCollectionACommentaire(vueARafraichir, collectionId, seqId); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, CollectionACommentaireListe commentairesAjoutees) { |
| if (commentairesAjoutees != null && commentairesAjoutees.size() > 0) { |
| for (Iterator<String> it = commentairesAjoutees.keySet().iterator(); it.hasNext();) { |
| modele.ajouterCollectionACommentaire(vueARafraichir, collectionId, (CollectionACommentaire) commentairesAjoutees.get(it.next())); |
| } |
| } |
| } |
| |
| /** MODIFIER **/ |
| public void modifierCollectionACommentaire(Rafraichissable vueARafraichir, CollectionACommentaireListe commentairesModifiees) { |
| if (commentairesModifiees != null && commentairesModifiees.size() > 0) { |
| for (Iterator<String> it = commentairesModifiees.keySet().iterator(); it.hasNext();) { |
| modele.modifierCollectionACommentaire(vueARafraichir, (CollectionACommentaire) commentairesModifiees.get(it.next())); |
| } |
| } |
| } |
| |
| /** SUPPRIMER **/ |
| public void supprimerCollectionACommentaire(Rafraichissable vueARafraichir, CollectionACommentaireListe commentairesSupprimees) { |
| if (commentairesSupprimees != null && commentairesSupprimees.size() > 0) { |
| String idCollectionACommentaireSeparesParVirgule = "" ; |
| for (Iterator<String> it = commentairesSupprimees.keySet().iterator(); it.hasNext();) { |
| idCollectionACommentaireSeparesParVirgule += commentairesSupprimees.get(it.next()).getId(); |
| if (it.hasNext()) { |
| idCollectionACommentaireSeparesParVirgule += ","; |
| } |
| } |
| modele.supprimerCollectionACommentaire(vueARafraichir, idCollectionACommentaireSeparesParVirgule, CollectionACommentaireAsyncDao.SUPPRESSION_PAR_COLLECTION); |
| } |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DES PERSONNES |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void afficherListePersonnes(PersonneListe personnesACharger) { |
| if (!(panneauCentre.getContenu() instanceof PersonneVue)) { |
| panneauCentre.removeAll(); |
| panneauCentre.add(new PersonneVue(this)); |
| panneauCentre.setId(ComposantId.PANNEAU_PERSONNE_LISTES); |
| } |
| |
| panneauCentre.getContenu().rafraichir(personnesACharger); |
| } |
| |
| public void afficherFormPersonne(String personneId) { |
| panneauCentre.removeAll(); |
| PersonneForm personneForm = new PersonneForm(this, personneId); |
| panneauCentre.add(personneForm); |
| |
| panneauCentre.layout(); |
| } |
| |
| public void clicListePersonne(Personne personne) { |
| panneauCentre.getContenu().rafraichir(personne); |
| } |
| |
| public void clicAjouterPersonne() { |
| afficherFormPersonne(null); |
| } |
| |
| public void clicModifierPersonne(List<Personne> selection) { |
| if (selection.size() == 0) { |
| InfoLogger.display("Information", "Veuillez sélectionner une personne."); |
| } else if (selection.size() > 1) { |
| InfoLogger.display("Information", "Veuillez sélectionner une seule personne à la fois."); |
| } else if (selection.size() == 1) { |
| afficherFormPersonne(selection.get(0).getId()); |
| } else { |
| InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierPersonne() du Médiateur."); |
| } |
| } |
| |
| |
| public void clicSupprimerPersonne(final Rafraichissable vue, final List<Personne> personneSelection) { |
| //Empecher suppression utilisateur |
| for (int i=0; i < personneSelection.size(); i++) { |
| Personne courante = personneSelection.get(i); |
| if (courante.getId().equals(getUtilisateurId())) { |
| InfoLogger.display("Information", "Vous ne pouvez pas supprimer votre compte"); |
| personneSelection.remove(courante); |
| } |
| } |
| |
| if (personneSelection.size() == 0) { |
| InfoLogger.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 idPersonneSepareParVirgule = "" ; |
| Iterator<Personne> itPersonne = personneSelection.iterator(); |
| while (itPersonne.hasNext()) { |
| Personne personneCourante = itPersonne.next(); |
| idPersonneSepareParVirgule += personneCourante.getId(); |
| idPersonneSepareParVirgule +=","; |
| } |
| modele.supprimerPersonne(vue, idPersonneSepareParVirgule); |
| } |
| } |
| }; |
| |
| MessageBox.confirm("Supprimer une personne", message, listenerSuppression); |
| } else { |
| InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerPersonne() du Médiateur."); |
| } |
| } |
| |
| /**************************************************************************************************** |
| /** selectionnerPersonne(Rafraichissable vueARafraichir, String recherche, int start, int nbElements) |
| /**************************************************************************************************** |
| * Action : |
| * -------- |
| * - Récupère un nombre défini de personnes en s'aidant du nom partiel ou complet de la personne. |
| * |
| * Description des paramètres : |
| * ---------------------------- |
| * - 'vueARafraichir' référence l'objet à mettre à jour après réception des données. |
| * - 'recherche' est une chaîne de caractères représentant tout ou partie du nom d'une personne. |
| * Si la chaîne est vide, alors toutes les personnes sont recherchées. |
| * - 'start' et 'nbElements' sont les paramètres indispensables à la pagination. 'start' |
| * est le paramètre qui décrit le numéro du tuple de départ et 'nbElements' le nombre |
| * d'éléments à collecter. |
| * |
| * Préconditions : |
| * --------------- |
| * - 'vueARafraichir' doit être non NULL et référencer un objet implémentant l'interface |
| * 'Rafraichissable' |
| * - 'recherche' doit être non NULL. |
| * - 'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro. |
| * |
| *****************************************************************************************************/ |
| public void selectionnerPersonne(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Personne"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerPersonne(vueARafraichir, recherche, start, nbElements, seqId); |
| } |
| |
| /** Cette méthode est un "wrapper" **/ |
| public void selectionnerPersonne(Rafraichissable vueARafraichir, Personne personne, String projetId, Sequenceur sequenceur) { |
| selectionnerPersonne(vueARafraichir, personne, projetId, 0, nbElements, sequenceur); |
| } |
| |
| public void selectionnerPersonne(Rafraichissable vueARafraichir, Personne personne, String projetId, int start, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Personne"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| String personneId = null; |
| String personneNom = null; |
| if (personne != null) { |
| personneId = personne.getId(); |
| personneNom = personne.getNom(); |
| } |
| modele.selectionnerPersonne(vueARafraichir, personneId, projetId, personneNom, start, nbElements, seqId); |
| } |
| |
| public void selectionnerPersonneParNomComplet(Rafraichissable vueARafraichir, String projetId, String nomComplet, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Personne"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerPersonne(vueARafraichir, null, projetId, nomComplet, 0, -1, seqId); |
| } |
| |
| public void selectionnerPersonneParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Personne"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerPersonne(vueARafraichir, null, projetId, null, 0, -1, seqId); |
| } |
| |
| /** ENREGISTRER **/ |
| 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 (!(panneauCentre.getContenu() instanceof PublicationVue)) { |
| panneauCentre.removeAll(); |
| panneauCentre.add(new PublicationVue(this)); |
| } |
| |
| panneauCentre.getContenu().rafraichir(nouvelleDonnees); |
| } |
| |
| public void afficherFormPublication(String publicationId) { |
| panneauCentre.removeAll(); |
| PublicationForm publicationForm = new PublicationForm(this, publicationId); |
| panneauCentre.add(publicationForm); |
| |
| panneauCentre.layout(); |
| } |
| |
| public void clicListePublication(Publication publication) { |
| if (publication != null) { |
| panneauCentre.getContenu().rafraichir(publication); |
| } |
| } |
| |
| public void clicAjouterPublication() { |
| afficherFormPublication(null); |
| } |
| |
| public void clicModifierPublication(List<Publication> selection) { |
| if (selection.size() == 0) { |
| InfoLogger.display("Information", "Veuillez sélectionner une publication."); |
| } else if (selection.size() > 1) { |
| InfoLogger.display("Information", "Veuillez sélectionner une seule publication à la fois."); |
| } else if (selection.size() == 1) { |
| afficherFormPublication(selection.get(0).getId()); |
| } else { |
| InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierPublication() du Médiateur."); |
| } |
| } |
| |
| 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 publications ?"; |
| 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)) { |
| supprimerPublication(panneauCentre.getContenu(), publicationListe); |
| } |
| } |
| }; |
| |
| MessageBox.confirm("Supprimer une publication", message, listenerSuppression); |
| } |
| } |
| |
| /** Cette méthode est un "wrapper" */ |
| public void selectionnerPublication(Rafraichissable vueARafraichir, String publicationId, Sequenceur sequenceur) { |
| selectionnerPublication(vueARafraichir, getProjetId(), publicationId, null, 0, nbElements, sequenceur); |
| } |
| |
| /** Cette méthode est un "wrapper" */ |
| public void selectionnerPublicationParNomComplet(Rafraichissable vueARafraichir, String projetId, String nomComplet) { |
| selectionnerPublication(vueARafraichir, projetId, null, nomComplet, 0, nbElements, null); |
| } |
| |
| public void selectionnerPublication(Rafraichissable vueARafraichir, String projetId, String publicationId, String nomComplet, int pageCourante, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Publication"); |
| Integer seqId = null; |
| if (sequenceur!=null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerPublication(vueARafraichir, publicationId, projetId, nomComplet, nbElements, pageCourante, seqId); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterPublication(Rafraichissable vueARafraichir, Publication publication, Integer seqId) { |
| modele.ajouterPublication(vueARafraichir, publication, seqId); |
| } |
| |
| /** MODIFIER **/ |
| public void modifierPublication(Rafraichissable vueARafraichir, Publication publication, Integer seqId) { |
| modele.modifierPublication(vueARafraichir, publication, seqId); |
| } |
| |
| /** SUPPRIMER **/ |
| public void supprimerPublication(Rafraichissable vueARafraichir, List<Publication> publicationsListe) { |
| if (publicationsListe != null && publicationsListe.size() > 0) { |
| String idPublicationSeparesParVirgule = "" ; |
| Iterator<Publication> it = publicationsListe.iterator(); |
| while (it.hasNext()) { |
| idPublicationSeparesParVirgule += it.next().getId(); |
| if (it.hasNext()) { |
| idPublicationSeparesParVirgule += ","; |
| } |
| } |
| modele.supprimerPublication(vueARafraichir, idPublicationSeparesParVirgule); |
| modele.supprimerPublicationAPersonne(vueARafraichir, idPublicationSeparesParVirgule); |
| } |
| } |
| |
| public void clicObtenirListeEditeurs(Rafraichissable vueARafraichir) { |
| selectionnerStructureParProjet(vueARafraichir, null, null); |
| } |
| |
| public void clicObtenirListeAuteurs(Rafraichissable vueARafraichir) { |
| selectionnerPersonneParProjet(vueARafraichir, null, null); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION de la relation PUBLICATION A PERSONNE |
| |
| public void selectionnerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, String roleId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner PublicationAPersonne"); |
| Integer seqId = null; |
| if (sequenceur != null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionPublicationAPersonne(vueARafraichir, publicationId, personnesId, roleId, seqId); |
| } |
| |
| public void selectionnerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, List<Valeur> roleId, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner PublicationAPersonne"); |
| Integer seqId = null; |
| if (sequenceur != null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| |
| String roleIds = ""; |
| Iterator<Valeur> itRole = roleId.iterator(); |
| while (itRole.hasNext()) { |
| roleIds+= itRole.next().getId(); |
| if (itRole.hasNext()) { |
| roleIds+=","; |
| } |
| } |
| modele.selectionPublicationAPersonne(vueARafraichir, publicationId, personnesId, roleIds, seqId); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, PublicationAPersonneListe personnesAjoutees, String roleId, Integer seqId) { |
| if (personnesAjoutees != null && personnesAjoutees.size() > 0) { |
| String idPublicationAPersonneSepareParVirgule = "" ; |
| for (Iterator<String> it = personnesAjoutees.keySet().iterator(); it.hasNext();) { |
| idPublicationAPersonneSepareParVirgule += personnesAjoutees.get(it.next()).getIdPersonne(); |
| if (it.hasNext()) { |
| idPublicationAPersonneSepareParVirgule += ","; |
| } |
| } |
| modele.ajouterPublicationAPersonne(vueARafraichir, publicationId, idPublicationAPersonneSepareParVirgule, roleId, seqId); |
| } |
| } |
| |
| |
| /** SUPPRIMER **/ |
| public void supprimerPublicationAPersonne(Rafraichissable vueARafraichir, PublicationAPersonneListe personnesSupprimees) { |
| if (personnesSupprimees != null && personnesSupprimees.size() > 0) { |
| String idPublicationAPersonneSepareParVirgule = "" ; |
| for (Iterator<String> it = personnesSupprimees.keySet().iterator(); it.hasNext();) { |
| idPublicationAPersonneSepareParVirgule += personnesSupprimees.get(it.next()).getId(); |
| if (it.hasNext()) { |
| idPublicationAPersonneSepareParVirgule += ","; |
| } |
| } |
| modele.supprimerPublicationAPersonne(vueARafraichir, idPublicationAPersonneSepareParVirgule); |
| } |
| } |
| |
| /** AJOUTER **/ |
| //Lier plusieurs publication à une personne |
| public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, PublicationAPersonneListe listePublications, String personneId, String roleId, Integer seqId) { |
| if (listePublications!=null && listePublications.size()>0) { |
| String idsPubli = ""; |
| String rolesIds = ""; |
| for (Iterator<String> it = listePublications.keySet().iterator(); it.hasNext();) { |
| PublicationAPersonne publi = listePublications.get(it.next()); |
| idsPubli += publi.getId(); |
| rolesIds += publi.getRole(); |
| if (it.hasNext()) { |
| idsPubli += ","; |
| rolesIds += ","; |
| } |
| } |
| modele.ajouterPublicationAPersonne(vueARafraichir, idsPubli, personneId, rolesIds, seqId); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DES COMMENTAIRES |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void afficherListeCommentaire(CommentaireListe nouvelleDonnees) { |
| if (!(panneauCentre.getContenu() instanceof CommentaireVue)) { |
| panneauCentre.removeAll(); |
| panneauCentre.add(new CommentaireVue(this)); |
| } |
| |
| panneauCentre.getContenu().rafraichir(nouvelleDonnees); |
| } |
| |
| public void afficherFormCommentaire(String commentaireId) { |
| panneauCentre.removeAll(); |
| CommentaireForm commentaireForm = new CommentaireForm(this, commentaireId); |
| panneauCentre.add(commentaireForm); |
| |
| panneauCentre.layout(); |
| } |
| |
| public void clicListeCommentaire(Commentaire commentaire) { |
| if (commentaire != null) { |
| panneauCentre.getContenu().rafraichir(commentaire); |
| } |
| } |
| |
| public void clicAjouterCommentaire() { |
| afficherFormCommentaire(null); |
| } |
| |
| public void clicModifierCommentaire(List<Commentaire> selection) { |
| if (selection.size() == 0) { |
| InfoLogger.display("Information", "Veuillez sélectionner un commentaire."); |
| } else if (selection.size() > 1) { |
| InfoLogger.display("Information", "Veuillez sélectionner un seul commentaire à la fois."); |
| } else if (selection.size() == 1) { |
| afficherFormCommentaire(selection.get(0).getId()); |
| } else { |
| InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierCommentaire() du Médiateur."); |
| } |
| } |
| |
| public void clicSupprimerCommentaire(final List<Commentaire> commentaireListe) { |
| if (commentaireListe.size() <= 0) { |
| MessageBox.alert("Attention", "Vous devez sélectionner un commentaire", null); |
| } else { |
| String message = "Voulez-vous vraiment supprimer ces commentaires ?"; |
| if (commentaireListe.size() == 1) { |
| message = "Voulez-vous vraiment supprimer ce commentaire ?"; |
| } |
| |
| 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)) { |
| supprimerCommentaire(panneauCentre.getContenu(), commentaireListe); |
| } |
| } |
| }; |
| |
| MessageBox.confirm("Supprimer un commentaire", message, listenerSuppression); |
| } |
| } |
| |
| /** Cette méthode est un wrapper **/ |
| public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, Sequenceur sequenceur) { |
| selectionnerCommentaire(vueARafraichir, commentaireId, null, 0, nbElements, sequenceur); |
| } |
| |
| public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, String titre, int pageCourante, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Commentaire"); |
| Integer seqId = null; |
| if (sequenceur != null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerCommentaire(vueARafraichir, commentaireId, getProjetId(), titre, pageCourante, nbElements, seqId); |
| } |
| |
| /** Cette méthode est un wrapper **/ |
| public void selectionnerCommentaireParTitre(Rafraichissable vueARafraichir, String titre, Sequenceur sequenceur) { |
| selectionnerCommentaire(vueARafraichir, null, titre, 0, nbElements, sequenceur); |
| } |
| |
| /** AJOUTER **/ |
| public void ajouterCommentaire(Rafraichissable vueARafraichir, Commentaire commentaire) { |
| modele.ajouterCommentaire(vueARafraichir, commentaire); |
| } |
| |
| /** MODIFIER **/ |
| public void modifierCommentaire(Rafraichissable vueARafraichir, Commentaire commentaire) { |
| modele.modifierCommentaire(vueARafraichir, commentaire); |
| } |
| |
| /** SUPPRIMER **/ |
| public void supprimerCommentaire(Rafraichissable vueARafraichir, List<Commentaire> commentairesListe) { |
| if (commentairesListe != null && commentairesListe.size() > 0) { |
| String idCommentaireSeparesParVirgule = "" ; |
| Iterator<Commentaire> it = commentairesListe.iterator(); |
| while (it.hasNext()) { |
| idCommentaireSeparesParVirgule += it.next().getId(); |
| if (it.hasNext()) { |
| idCommentaireSeparesParVirgule += ","; |
| } |
| } |
| modele.supprimerCommentaire(vueARafraichir, idCommentaireSeparesParVirgule); |
| modele.supprimerCollectionACommentaire(vueARafraichir, idCommentaireSeparesParVirgule, CollectionACommentaireAsyncDao.SUPPRESSION_PAR_COMMENTAIRE); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // RAFRAICHISSEMENT |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void rafraichir(Object nouvellesDonnees) { |
| if (nouvellesDonnees instanceof Utilisateur) { |
| repandreEtatIdentification((Utilisateur) nouvellesDonnees); |
| } else if (nouvellesDonnees instanceof Information) { |
| Information info = (Information) nouvellesDonnees; |
| if (info.getType().equals("modification_personne")) { |
| repandreInfoMiseAJourUtilisateur(); |
| } |
| } else { |
| GWT.log(i18nM.erreurRafraichir(nouvellesDonnees.getClass(), 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(); |
| } |
| |
| public String obtenirClasseContenu() { |
| String classeContenu = null; |
| if (panneauCentre.getContenu() != null) { |
| classeContenu = panneauCentre.getContenu().getClass().toString(); |
| } |
| return classeContenu; |
| } |
| |
| } |
| Property changes: |
|---|
| Added: svn:mergeinfo |
|---|
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/Mediateur.java:r1136-1368 |
|---|