| New file |
|---|
| 0,0 → 1,1802 |
|---|
| package org.tela_botanica.client; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| import org.mortbay.util.ajax.JSON; |
| 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.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.publication.Publication; |
| import org.tela_botanica.client.modeles.publication.PublicationAPersonne; |
| import org.tela_botanica.client.modeles.publication.PublicationAPersonneAsyncDao; |
| import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe; |
| import org.tela_botanica.client.modeles.publication.PublicationAsyncDao; |
| 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.util.Analytics; |
| import org.tela_botanica.client.util.Debug; |
| import org.tela_botanica.client.util.Log; |
| import org.tela_botanica.client.util.UtilArray; |
| import org.tela_botanica.client.vues.ContenuVue; |
| import org.tela_botanica.client.vues.EnteteVue; |
| import org.tela_botanica.client.vues.FenetreForm; |
| import org.tela_botanica.client.vues.Formulaire; |
| import org.tela_botanica.client.vues.FenetreJournal; |
| import org.tela_botanica.client.vues.MenuHorizontalVue; |
| import org.tela_botanica.client.vues.PopupChargement; |
| import org.tela_botanica.client.vues.StatutVue; |
| import org.tela_botanica.client.vues.accueil.AccueilVue; |
| import org.tela_botanica.client.vues.accueil.StatistiquesVue; |
| 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.publication.PublicationForm; |
| import org.tela_botanica.client.vues.publication.PublicationImportForm; |
| import org.tela_botanica.client.vues.publication.PublicationListeVue; |
| 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.Style.Orientation; |
| 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.ContentPanel; |
| import com.extjs.gxt.ui.client.widget.Dialog; |
| 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.extjs.gxt.ui.client.widget.layout.LayoutData; |
| import com.extjs.gxt.ui.client.widget.layout.RowData; |
| import com.extjs.gxt.ui.client.widget.layout.RowLayout; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.dev.jjs.ast.js.JsonArray; |
| import com.google.gwt.dev.json.JsonObject; |
| import com.google.gwt.dev.json.JsonValue; |
| import com.google.gwt.event.logical.shared.ValueChangeEvent; |
| import com.google.gwt.event.logical.shared.ValueChangeHandler; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.i18n.client.Dictionary; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.History; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.RootPanel; |
| import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteEvent; |
| import com.google.gwt.user.client.ui.FormPanel.SubmitEvent; |
| |
| public class Mediateur implements Rafraichissable, ValueChangeHandler<String> { |
| |
| private Viewport viewport; |
| private Modele modele = null; |
| public static final Constantes i18nC = getI18nConstante(); |
| public static final ErrorMessages i18nM = getI18nMessage(); |
| public static final boolean DEBUG = false; |
| public static final boolean DEBUG_CHARGEMENT = false; |
| |
| private String requeteUrl = null; |
| |
| private EnteteVue panneauNord = null; |
| private ContenuVue panneauCentre = null; |
| private StatutVue panneauSud = null; |
| private FenetreJournal fenetreJournal = null; |
| private MenuHorizontalVue panneauNavigation = null; |
| |
| private HashMap<Object, Integer> fileDAttenteChargement = null; |
| |
| private IdentificationFenetre fenetreIdentification = null; |
| private int nbElements = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage")); |
| |
| private Sequenceur sequenceur = null; |
| private boolean premierChargement = true; |
| |
| 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(); |
| |
| // Séquenceur (local au médiateur) |
| sequenceur = new Sequenceur(); |
| |
| // Création du Viewport qui contient la disposition globale de l'application |
| viewport = new Viewport(); |
| viewport.setLayout(new BorderLayout()); |
| |
| panneauNavigation = new MenuHorizontalVue(this); |
| |
| // Création des différents panneaux |
| creerPanneauNord(); |
| creerPanneauCentral(); |
| creerPanneauSud(); |
| fenetreJournal = new FenetreJournal(this); |
| |
| // Connexion de l'utilisateur |
| getEtatUtilisateur(); |
| |
| // Creer la table qui gère le panneau de chargement/déchargement |
| fileDAttenteChargement = new HashMap<Object, Integer>(); |
| |
| // Gestion de l'historique du navigateur |
| History.addValueChangeHandler(this);// Ajout du médiateur comme écouteur des changements de l'historique |
| if ("".equals(History.getToken())) { |
| History.newItem(MenuApplicationId.ACCUEIL); |
| } else { |
| History.fireCurrentHistoryState(); |
| } |
| |
| // 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_TESTEURS, apropos.getTesteurs()); |
| Registry.register(RegistreId.APPLI_LICENCE, apropos.getLicence()); |
| |
| Registry.register(RegistreId.APPLI_REVISION, apropos.getRevisionGlobale()); |
| Registry.register(RegistreId.SERVICES_REVISION, apropos.getRevisionGlobaleServices()); |
| 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()); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // 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 creerPanneauCentral() { |
| |
| ContentPanel panneauIntermediaire = new ContentPanel(); |
| panneauIntermediaire.setLayout(new RowLayout(Orientation.VERTICAL)); |
| panneauIntermediaire.setHeaderVisible(false); |
| |
| panneauCentre = new ContenuVue(this); |
| |
| BorderLayoutData regionCentre = new BorderLayoutData(LayoutRegion.CENTER); |
| regionCentre.setMargins(new Margins(5, 5, 5, 0)); |
| |
| panneauNavigation.setHeight(28); |
| panneauNavigation.setBodyBorder(false); |
| panneauNavigation.setBorders(false); |
| |
| panneauIntermediaire.add(panneauNavigation, new RowData(1, -1, new Margins(0))); |
| panneauIntermediaire.add(panneauCentre, new RowData(1, 1, new Margins(0))); |
| |
| viewport.add(panneauIntermediaire, 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) { |
| boolean codeOk = true; |
| if (codeMenuClique.equals(MenuApplicationId.ACCUEIL)) { |
| afficherAccueil(); |
| } else if (codeMenuClique.equals(MenuApplicationId.STRUCTURE)) { |
| selectionnerStructure(panneauCentre, null, null, false); |
| } else if (codeMenuClique.equals(MenuApplicationId.COLLECTION)) { |
| selectionnerCollection(panneauCentre, null, null, null); |
| } else if (codeMenuClique.equals(MenuApplicationId.PERSONNE)) { |
| selectionnerPersonne(panneauCentre, null, null); |
| } else if (codeMenuClique.equals(MenuApplicationId.PUBLICATION)) { |
| selectionnerPublication(panneauCentre, null, null); |
| } else if (codeMenuClique.equals(MenuApplicationId.COMMENTAIRE)) { |
| selectionnerCommentaire(panneauCentre, null, null); |
| } else if (codeMenuClique.equals(MenuApplicationId.STATS)) { |
| // l'affichage des statistiques ne nécessite pas de chargement |
| afficherStats(); |
| } else { |
| Log.debug(i18nM.nonImplemente(codeMenuClique)); |
| codeOk = false; |
| } |
| |
| // Le code menu est valide |
| if (codeOk == true) { |
| // Sélection du menu |
| panneauNavigation.selectionMenu(codeMenuClique); |
| // Gestion de l'historique |
| if (requeteUrl == null) { |
| History.newItem(codeMenuClique); |
| } else { |
| History.newItem(codeMenuClique+"?"+requeteUrl); |
| } |
| // Ajout des stats Google Analytics |
| Analytics.pageVisitee(codeMenuClique); |
| // Rafraichissement du panneau central |
| panneauCentre.layout(); |
| viewport.layout(); |
| } |
| } |
| |
| public void activerChargement(Object caller, String message) { |
| if (fileDAttenteChargement.get(caller) == null) fileDAttenteChargement.put(caller, 1); |
| else fileDAttenteChargement.put(caller, fileDAttenteChargement.get(caller)+1); |
| activerChargement(message); |
| } |
| |
| private void activerChargement(String message) { |
| if (DEBUG_CHARGEMENT) System.out.println("[CHARGEMENT] ActiverChargement"); |
| if (DEBUG_CHARGEMENT) debugFileAttente(); |
| afficherPopinChargement(); |
| panneauCentre.disable(); |
| panneauSud.showBusy(i18nC.chargement()+" "+message); |
| } |
| |
| public void desactiverChargement(Object caller) { |
| if (fileDAttenteChargement.get(caller) == null) { |
| if (DEBUG_CHARGEMENT) System.out.println("[CHARGEMENT] Problème : l'objet "+caller+" essaie de désactiver le chargement alors qu'il ne l'a pas initié."); |
| } |
| else fileDAttenteChargement.put(caller, fileDAttenteChargement.get(caller)-1); |
| |
| if (!chargementsEnCours()) desactiverChargement(); |
| else if (DEBUG_CHARGEMENT) { |
| System.out.println("[CHARGEMENT] Patienter, il y a encore un chargement en cours."); |
| debugFileAttente(); |
| } |
| } |
| |
| private void desactiverChargement() { |
| if (DEBUG_CHARGEMENT) System.out.println("[CHARGEMENT] Désactiver Chargement"); |
| if (DEBUG_CHARGEMENT) debugFileAttente(); |
| masquerPopinChargement(); |
| panneauCentre.enable(); |
| panneauSud.clear(); |
| } |
| |
| private boolean chargementsEnCours() { |
| boolean chargementEnCours = false; |
| Iterator<Object> it = fileDAttenteChargement.keySet().iterator(); |
| while (it.hasNext() && !chargementEnCours) { |
| chargementEnCours = (fileDAttenteChargement.get(it.next()) > 0); |
| } |
| return chargementEnCours; |
| } |
| |
| private void debugFileAttente() { |
| System.out.println("[CHARGEMENT]--< StackTrace >------------------------------------------------------"); |
| if (fileDAttenteChargement.size() == 0) System.out.println("(Empty)"); |
| Iterator<Object> it = fileDAttenteChargement.keySet().iterator(); |
| while (it.hasNext()) { |
| Object o = it.next(); |
| System.out.println(" ["+o+"] = "+fileDAttenteChargement.get(o)); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // 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_CONTACT)) { |
| String urlWidgetRemarques = ((Configuration) Registry.get(RegistreId.CONFIG)).getUrl("remarques") |
| + "?service=coel&pageSource=" + URL.encodeQueryString(Window.Location.getHref()); |
| Window.open(urlWidgetRemarques, "Remarques", ""); |
| } |
| } |
| |
| public void afficherFenetreLicence(IdentificationFenetre vue) { |
| 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 getEtatUtilisateur() { |
| modele.getEtatUtilisateur(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); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // 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 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; |
| } |
| |
| final FenetreForm fenetre = new FenetreForm(""); |
| Sequenceur sequenceur = new Sequenceur(); |
| StructureForm structureForm = new StructureForm(this, mode, sequenceur) { |
| @Override |
| public void surFermetureFormulaire() { |
| fenetre.hide(); |
| } |
| }; |
| structureForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu(); |
| fenetre.add(structureForm); |
| fenetre.show(); |
| |
| if (mode.equals(Formulaire.MODE_MODIFIER)) { |
| selectionnerStructure(structureForm, structureId, sequenceur, false); |
| 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); |
| selectionnerCollectionAStructure(panneauCentre.getContenu(), structure.getId()); |
| } |
| } |
| |
| 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.getHtml().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, boolean searchCity) { |
| 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, searchCity); |
| } |
| |
| public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, Sequenceur sequenceur, boolean searchCity) { |
| if (Mediateur.DEBUG) { |
| System.out.println("MEDIATEUR - selectionner Structure"); |
| } |
| Integer seqId = null; |
| if (sequenceur != null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| |
| modele.selectionnerStructure(vueARafraichir, structureId, null, 0, nbElements, seqId, searchCity); |
| } |
| |
| public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, String nom, int start, int nbElements, Sequenceur sequenceur, boolean searchCity) { |
| if (Mediateur.DEBUG) { |
| System.out.println("MEDIATEUR - selectionner Structure"); |
| } |
| Integer seqId = null; |
| if (sequenceur != null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerStructure(vueARafraichir, structureId, nom, start, nbElements, seqId, searchCity); |
| } |
| |
| public void selectionnerStructureAvecPaginationProgressive(Rafraichissable vueARafraichir, String structureId, String nom, String formatRetour, int start, int nbElements, Sequenceur sequenceur, boolean searchCity) { |
| if (Mediateur.DEBUG) { |
| System.out.println("MEDIATEUR - selectionner Structure"); |
| } |
| Integer seqId = null; |
| if (sequenceur != null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerStructureAvecPaginationProgressive(vueARafraichir, structureId, nom, formatRetour, start, nbElements, seqId, searchCity); |
| } |
| |
| |
| private void selectionnerCollectionAStructure(Rafraichissable vueARafraichir, String structureId) { |
| if (Mediateur.DEBUG) { |
| System.out.println("MEDIATEUR - selectionner Collection à structure"); |
| } |
| Integer seqId = null; |
| if (sequenceur != null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionnerCollectionAStructure(vueARafraichir, structureId, 0, 10, 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, String nom, int start, int nbElements, 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, nom, start, nbElements, seqId); |
| } |
| |
| 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) { |
| final FenetreForm fenetre = new FenetreForm(""); |
| CollectionForm collectionForm = new CollectionForm(this, collectionId) { |
| @Override |
| public void surFermetureFormulaire() { |
| fenetre.hide(); |
| } |
| }; |
| collectionForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu(); |
| fenetre.add(collectionForm); |
| fenetre.show(); |
| } |
| |
| public void clicListeCollection(Collection collectionCliquee) { |
| panneauCentre.getContenu().rafraichir(collectionCliquee); |
| if (collectionCliquee != null) { |
| selectionnerCollectionAPersonne(panneauCentre.getContenu(), collectionCliquee.getId(), null, sequenceur); |
| selectionnerCollectionAPublication(panneauCentre.getContenu(), collectionCliquee.getId(), sequenceur); |
| selectionnerCollectionACommentaire(panneauCentre.getContenu(), collectionCliquee.getId(), sequenceur); |
| } |
| } |
| |
| 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.getHtml().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, collectionId, nom, start, nbElements, 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, String recherche, int start, int nbElements, 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, recherche, start, nbElements, seqId); |
| } |
| |
| 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, String recherche, int start, int nbElements, 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, recherche, start, nbElements, seqId); |
| } |
| |
| 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); |
| } |
| |
| public void selectionnerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, String recherche, int pageCourante, int nbElements, 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, recherche, pageCourante, nbElements, 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) { |
| final FenetreForm fenetre = new FenetreForm(""); |
| PersonneForm personneForm = new PersonneForm(this, personneId) { |
| @Override |
| public void surFermetureFormulaire() { |
| fenetre.hide(); |
| } |
| }; |
| personneForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu(); |
| fenetre.add(personneForm); |
| fenetre.show(); |
| } |
| |
| 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.getHtml().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); |
| } |
| |
| public void selectionnerPersonne(Rafraichissable vueARafraichir, Personne personne, 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, personneNom, start, nbElements, seqId); |
| } |
| |
| public void selectionnerPersonne(Rafraichissable vueARafraichir, String idPersonne, 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, idPersonne, null, 0, nbElements, seqId); |
| } |
| |
| public void selectionnerPersonneParNomComplet(Rafraichissable vueARafraichir, 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, nomComplet, 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) { |
| final FenetreForm fenetre = new FenetreForm(""); |
| PublicationForm publicationForm = new PublicationForm(this, publicationId) { |
| @Override |
| public void surFermetureFormulaire() { |
| fenetre.hide(); |
| } |
| }; |
| publicationForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu(); |
| fenetre.add(publicationForm); |
| fenetre.show(); |
| } |
| |
| 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 messageComplement = "(ceci supprimera également les liens avec leurs auteurs et leurs collections)"; |
| String message = "Voulez-vous vraiment supprimer ces publications "+messageComplement+" ?"; |
| if (publicationListe.size() == 1) { |
| message = "Voulez-vous vraiment supprimer cette publication "+messageComplement+" ?"; |
| } |
| |
| final Listener<MessageBoxEvent> listenerSuppression = new Listener<MessageBoxEvent>() { |
| public void handleEvent(MessageBoxEvent ce) { |
| Dialog dialog = (Dialog) ce.getComponent(); |
| Button btn = ce.getButtonClicked(); |
| |
| if (btn.getHtml().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, publicationId, null, 0, nbElements, sequenceur); |
| } |
| |
| /** Cette méthode est un "wrapper" */ |
| public void selectionnerPublicationParNomComplet(Rafraichissable vueARafraichir, String nomComplet) { |
| selectionnerPublication(vueARafraichir, null, nomComplet, 0, nbElements, null); |
| } |
| |
| public void selectionnerPublication(Rafraichissable vueARafraichir, 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, nomComplet, pageCourante, nbElements, seqId); |
| } |
| |
| public void selectionnerPublication(Rafraichissable vueARafraichir, String recherche, int start, 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, recherche, start, nbElements, 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); |
| } |
| } |
| |
| public void clicImporterPublication(final PublicationListeVue publiListeVue) { |
| final FenetreForm fenetre = new FenetreForm(Mediateur.i18nC.importDePubli()); |
| fenetre.add(new PublicationImportForm(this) { |
| |
| @Override |
| public void surSoumissionFormulaire(SubmitEvent event) { |
| afficherPopinChargement(); |
| } |
| |
| @Override |
| public void surFormulaireEnvoye(JSONValue responseValue) { |
| traiterRetourImportFormulaire(responseValue); |
| publiListeVue.afficherDernierePage(); |
| fenetre.hide(); |
| } |
| |
| @Override |
| public void surClicAnnuler() { |
| fenetre.hide(); |
| } |
| }); |
| fenetre.setTailleFenetre(75, 300); |
| fenetre.show(); |
| } |
| |
| private void traiterRetourImportFormulaire(JSONValue responseValue) { |
| String message = ""; |
| |
| if(PublicationAsyncDao.importEstUnSucces(responseValue)) { |
| String nbPubliImportee = PublicationAsyncDao.getNbPublisImportees(responseValue); |
| int nbPublint = Integer.parseInt(nbPubliImportee); |
| message = (nbPublint == 1) ? i18nM.retourSuccesImportPublication(nbPubliImportee) : |
| i18nM.retourSuccesImportPublicationPluriel(nbPubliImportee); |
| |
| // Tri artificiel par id de publications pour voir apparaître ce qui vient d'être importé |
| PublicationAsyncDao.tri = "cpu_id_publication"; |
| } else { |
| message = i18nM.retourEchecImportPublication(PublicationAsyncDao.getErreursImport(responseValue)); |
| } |
| Window.alert(message); |
| masquerPopinChargement(); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // 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); |
| } |
| |
| public void selectionnerPublicationsAPersonne(Rafraichissable vueARafraichir, String personneId, List<Valeur> roleId, String recherche, int pageCourante, int nbElements, 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.selectionPublicationsAPersonne(vueARafraichir, personneId, roleIds, recherche, pageCourante, nbElements, seqId); |
| } |
| |
| public void selectionnerPersonnesAPublication(Rafraichissable vueARafraichir, String publicationId, String recherche, int pageCourante, int nbElements, Sequenceur sequenceur) { |
| if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner PublicationAPersonne"); |
| Integer seqId = null; |
| if (sequenceur != null) { |
| seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir); |
| vueARafraichir = sequenceur; |
| } |
| modele.selectionPersonnesAPublication(vueARafraichir, publicationId, recherche, pageCourante, nbElements, seqId); |
| } |
| |
| /** AJOUTER **/ |
| // Lier une publication à plusieurs personnes |
| public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, PublicationAPersonneListe personnesAjoutees, String roleId, Integer seqId) { |
| if (personnesAjoutees != null && personnesAjoutees.size() > 0) { |
| String idPublicationAPersonneSepareParVirgule = "" ; |
| String ordreAuteursSepareParVirgule = ""; |
| for (Iterator<String> it = personnesAjoutees.keySet().iterator(); it.hasNext();) { |
| PublicationAPersonne publi = personnesAjoutees.get(it.next()); |
| idPublicationAPersonneSepareParVirgule += publi.getIdPersonne(); |
| ordreAuteursSepareParVirgule += publi.getOrdreAuteurs(); |
| if (it.hasNext()) { |
| idPublicationAPersonneSepareParVirgule += ","; |
| ordreAuteursSepareParVirgule += ","; |
| } |
| } |
| modele.ajouterPublicationAPersonne(vueARafraichir, publicationId, idPublicationAPersonneSepareParVirgule, ordreAuteursSepareParVirgule, roleId, seqId); |
| } |
| } |
| |
| // 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 = ""; |
| String ordreAuteurs = ""; |
| for (Iterator<String> it = listePublications.keySet().iterator(); it.hasNext();) { |
| PublicationAPersonne publiAPersonne = listePublications.get(it.next()); |
| idsPubli += publiAPersonne.getIdPublication(); |
| rolesIds += publiAPersonne.getRole(); |
| ordreAuteurs += publiAPersonne.getOrdreAuteurs(); |
| if (it.hasNext()) { |
| idsPubli += ","; |
| rolesIds += ","; |
| ordreAuteurs += ","; |
| } |
| } |
| modele.ajouterPublicationAPersonne(vueARafraichir, idsPubli, personneId, ordreAuteurs, rolesIds, seqId); |
| } |
| } |
| |
| /** MODIFIER **/ |
| public void modifierPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, PublicationAPersonneListe personnesModifiees, String roleId, Integer seqId) { |
| if (personnesModifiees != null && personnesModifiees.size() > 0) { |
| String idPublicationAPersonneSepareParVirgule = "" ; |
| String ordreAuteursSepareParVirgule = ""; |
| for (Iterator<String> it = personnesModifiees.keySet().iterator(); it.hasNext();) { |
| PublicationAPersonne publi = personnesModifiees.get(it.next()); |
| idPublicationAPersonneSepareParVirgule += publi.getIdPersonne(); |
| ordreAuteursSepareParVirgule += publi.getOrdreAuteurs(); |
| if (it.hasNext()) { |
| idPublicationAPersonneSepareParVirgule += ","; |
| ordreAuteursSepareParVirgule += ","; |
| } |
| } |
| modele.modifierPublicationAPersonne(vueARafraichir, publicationId, idPublicationAPersonneSepareParVirgule, ordreAuteursSepareParVirgule, 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); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // 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) { |
| final FenetreForm fenetre = new FenetreForm(""); |
| CommentaireForm commentaireForm = new CommentaireForm(this, commentaireId) { |
| @Override |
| public void surFermetureFormulaire() { |
| fenetre.hide(); |
| } |
| }; |
| commentaireForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu(); |
| fenetre.add(commentaireForm); |
| fenetre.show(); |
| } |
| |
| 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.getHtml().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, titre, pageCourante, nbElements, seqId); |
| } |
| |
| public void selectionnerCommentaire(Rafraichissable vueARafraichir, String recherche, 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, recherche, 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); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DES STATS |
| //+----------------------------------------------------------------------------------------------------------------+ |
| public void afficherStats() { |
| if (!(panneauCentre.getContenu() instanceof StatistiquesVue)) { |
| panneauCentre.removeAll(); |
| panneauCentre.add(new StatistiquesVue(this)); |
| } |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // RAFRAICHISSEMENT |
| //+----------------------------------------------------------------------------------------------------------------+ |
| |
| public void rafraichir(Object nouvellesDonnees) { |
| //Coel.LogVersFirebug("rafraichit mediateur"); |
| if (nouvellesDonnees instanceof Utilisateur) { |
| Utilisateur infoUtil = (Utilisateur) nouvellesDonnees; |
| //Coel.LogVersFirebug("Licence dans util : " + infoUtil.avoirLicenceAcceptee()); |
| //Coel.LogVersFirebug("Licence dans util : " + infoUtil.getLicence()); |
| if (infoUtil.getLicence().equals("0")) { |
| this.afficherFenetreLicence(this.fenetreIdentification); |
| } else { |
| repandreEtatIdentification(infoUtil); |
| } |
| } 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; |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION de l'HISTORIQUE du navigateur |
| //+----------------------------------------------------------------------------------------------------------------+ |
| @Override |
| public void onValueChange(ValueChangeEvent<String> event) { |
| String token = event.getValue(); |
| if(premierChargement) { |
| if (token != null) { |
| if (token.lastIndexOf("?") == -1) { |
| this.requeteUrl = null; |
| this.clicMenu(token); |
| } else { |
| int indexDebutRequete = (token.lastIndexOf("?") + 1); |
| int indexFinPlace = token.lastIndexOf("?"); |
| String place = token.substring(0, indexFinPlace); |
| requeteUrl = token.substring(indexDebutRequete); |
| Log.trace("URL Place : "+place); |
| Log.trace("URL Requete : "+requeteUrl); |
| analyseRequeteURL(); |
| this.clicMenu(place); |
| } |
| } |
| } |
| premierChargement = false; |
| } |
| |
| private void analyseRequeteURL() { |
| String[] params = requeteUrl.split("&"); |
| for (int i = 0; i < params.length; i++) { |
| if (params[i].startsWith("logLevel=")) { |
| String logLevel = params[i].replaceFirst("^logLevel=", ""); |
| Log.setNiveau(logLevel); |
| } |
| } |
| } |
| } |
| Property changes: |
|---|
| Added: svn:mergeinfo |
|---|
| Merged /branches/v1.6-muscardin/src/org/tela_botanica/client/Mediateur.java:r1816-1817 |
|---|
| Merged /trunk/src/org/tela_botanica/client/Mediateur.java:r11-59,1209-1382 |
|---|
| Merged /branches/v1.1-aramon/src/org/tela_botanica/client/Mediateur.java:r1383-1511 |
|---|
| Merged /branches/v1.0-syrah/src/org/tela_botanica/client/Mediateur.java:r1136-1368 |
|---|