Subversion Repositories eFlore/Applications.coel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
60 jpm 1
package org.tela_botanica.client;
2
 
1562 jpm 3
import java.util.ArrayList;
1468 jpm 4
import java.util.HashMap;
231 jp_milcent 5
import java.util.Iterator;
134 jpm 6
import java.util.List;
1562 jpm 7
import java.util.logging.Level;
8
import java.util.logging.Logger;
134 jpm 9
 
61 jpm 10
import org.tela_botanica.client.composants.AideFenetre;
60 jpm 11
import org.tela_botanica.client.composants.IdentificationFenetre;
1210 cyprien 12
import org.tela_botanica.client.composants.InfoLogger;
898 gduche 13
import org.tela_botanica.client.composants.LicenceFenetre;
1023 jpm 14
import org.tela_botanica.client.composants.AproposFenetre;
907 jpm 15
import org.tela_botanica.client.configuration.APropos;
16
import org.tela_botanica.client.configuration.Configuration;
358 jp_milcent 17
import org.tela_botanica.client.i18n.Constantes;
466 gduche 18
import org.tela_botanica.client.i18n.ErrorMessages;
119 jpm 19
import org.tela_botanica.client.interfaces.Rafraichissable;
156 jp_milcent 20
import org.tela_botanica.client.modeles.Information;
327 jp_milcent 21
import org.tela_botanica.client.modeles.MenuApplicationId;
61 jpm 22
import org.tela_botanica.client.modeles.Utilisateur;
1014 gduche 23
import org.tela_botanica.client.modeles.Valeur;
935 jpm 24
import org.tela_botanica.client.modeles.collection.Collection;
989 jpm 25
import org.tela_botanica.client.modeles.collection.CollectionACommentaire;
26
import org.tela_botanica.client.modeles.collection.CollectionACommentaireAsyncDao;
27
import org.tela_botanica.client.modeles.collection.CollectionACommentaireListe;
935 jpm 28
import org.tela_botanica.client.modeles.collection.CollectionAPersonne;
29
import org.tela_botanica.client.modeles.collection.CollectionAPersonneListe;
30
import org.tela_botanica.client.modeles.collection.CollectionAPublication;
31
import org.tela_botanica.client.modeles.collection.CollectionAPublicationListe;
32
import org.tela_botanica.client.modeles.collection.CollectionListe;
985 jpm 33
import org.tela_botanica.client.modeles.commentaire.Commentaire;
34
import org.tela_botanica.client.modeles.commentaire.CommentaireListe;
935 jpm 35
import org.tela_botanica.client.modeles.personne.Personne;
36
import org.tela_botanica.client.modeles.personne.PersonneListe;
37
import org.tela_botanica.client.modeles.projet.Projet;
38
import org.tela_botanica.client.modeles.projet.ProjetListe;
39
import org.tela_botanica.client.modeles.publication.Publication;
40
import org.tela_botanica.client.modeles.publication.PublicationAPersonne;
41
import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe;
42
import org.tela_botanica.client.modeles.publication.PublicationListe;
43
import org.tela_botanica.client.modeles.structure.Structure;
44
import org.tela_botanica.client.modeles.structure.StructureAPersonne;
45
import org.tela_botanica.client.modeles.structure.StructureAPersonneListe;
46
import org.tela_botanica.client.modeles.structure.StructureConservation;
47
import org.tela_botanica.client.modeles.structure.StructureListe;
48
import org.tela_botanica.client.modeles.structure.StructureValorisation;
1324 gduche 49
import org.tela_botanica.client.synchronisation.Sequenceur;
1428 cyprien 50
import org.tela_botanica.client.util.Debug;
1562 jpm 51
import org.tela_botanica.client.util.Log;
52
import org.tela_botanica.client.util.UtilArray;
936 jpm 53
import org.tela_botanica.client.vues.ContenuVue;
444 jp_milcent 54
import org.tela_botanica.client.vues.EnteteVue;
1613 aurelien 55
import org.tela_botanica.client.vues.FenetreForm;
641 jp_milcent 56
import org.tela_botanica.client.vues.Formulaire;
1210 cyprien 57
import org.tela_botanica.client.vues.FenetreJournal;
982 jpm 58
import org.tela_botanica.client.vues.NavigationVue;
332 gduche 59
import org.tela_botanica.client.vues.PopupChargement;
443 jp_milcent 60
import org.tela_botanica.client.vues.StatutVue;
912 jpm 61
import org.tela_botanica.client.vues.accueil.AccueilVue;
934 jpm 62
import org.tela_botanica.client.vues.collection.CollectionForm;
63
import org.tela_botanica.client.vues.collection.CollectionListeVue;
64
import org.tela_botanica.client.vues.collection.CollectionVue;
989 jpm 65
import org.tela_botanica.client.vues.commentaire.CommentaireForm;
985 jpm 66
import org.tela_botanica.client.vues.commentaire.CommentaireVue;
935 jpm 67
import org.tela_botanica.client.vues.personne.PersonneForm;
68
import org.tela_botanica.client.vues.personne.PersonneVue;
69
import org.tela_botanica.client.vues.projet.ProjetForm;
70
import org.tela_botanica.client.vues.projet.ProjetVue;
71
import org.tela_botanica.client.vues.publication.PublicationForm;
72
import org.tela_botanica.client.vues.publication.PublicationVue;
73
import org.tela_botanica.client.vues.structure.StructureForm;
74
import org.tela_botanica.client.vues.structure.StructureVue;
467 jp_milcent 75
 
60 jpm 76
import com.extjs.gxt.ui.client.Registry;
77
import com.extjs.gxt.ui.client.Style.LayoutRegion;
315 gduche 78
import com.extjs.gxt.ui.client.event.Listener;
502 gduche 79
import com.extjs.gxt.ui.client.event.MessageBoxEvent;
60 jpm 80
import com.extjs.gxt.ui.client.util.Margins;
315 gduche 81
import com.extjs.gxt.ui.client.widget.Dialog;
82
import com.extjs.gxt.ui.client.widget.MessageBox;
60 jpm 83
import com.extjs.gxt.ui.client.widget.Viewport;
315 gduche 84
import com.extjs.gxt.ui.client.widget.button.Button;
60 jpm 85
import com.extjs.gxt.ui.client.widget.layout.BorderLayout;
86
import com.extjs.gxt.ui.client.widget.layout.BorderLayoutData;
91 jpm 87
import com.google.gwt.core.client.GWT;
1509 jpm 88
import com.google.gwt.event.logical.shared.ValueChangeEvent;
89
import com.google.gwt.event.logical.shared.ValueChangeHandler;
1562 jpm 90
import com.google.gwt.http.client.URL;
599 gduche 91
import com.google.gwt.i18n.client.Dictionary;
1509 jpm 92
import com.google.gwt.user.client.History;
60 jpm 93
import com.google.gwt.user.client.Window;
94
import com.google.gwt.user.client.ui.RootPanel;
95
 
1509 jpm 96
public class Mediateur implements Rafraichissable, ValueChangeHandler<String> {
60 jpm 97
 
358 jp_milcent 98
	private Viewport viewport;
119 jpm 99
	private Modele modele = null;
582 jp_milcent 100
	public static final Constantes i18nC = getI18nConstante();
101
	public static final ErrorMessages i18nM = getI18nMessage();
1637 aurelien 102
	public static final boolean DEBUG = false;
103
	public static final boolean DEBUG_CHARGEMENT = false;
119 jpm 104
 
1562 jpm 105
	private String requeteUrl = null;
106
 
444 jp_milcent 107
	private EnteteVue panneauNord = null;
982 jpm 108
	private NavigationVue panneauOuest = null;
444 jp_milcent 109
	private ContenuVue panneauCentre = null;
443 jp_milcent 110
	private StatutVue panneauSud = null;
1210 cyprien 111
	private FenetreJournal fenetreJournal = null;
60 jpm 112
 
1468 jpm 113
	private HashMap<Object, Integer> fileDAttenteChargement = null;
114
 
358 jp_milcent 115
	private IdentificationFenetre fenetreIdentification = null;
1041 gduche 116
	private int nbElements = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage"));
1156 jpm 117
 
1468 jpm 118
	private Sequenceur sequenceur = null;
1633 aurelien 119
	private boolean premierChargement = true;
1468 jpm 120
 
60 jpm 121
	public Mediateur() {
122
		// Enregistrement du Médiateur dans le Registre
123
		Registry.register(RegistreId.MEDIATEUR, this);
765 jpm 124
 
125
		//Initialisation du Registre
126
		initialiserRegistre();
466 gduche 127
 
60 jpm 128
		// Création du Modèle qui s'enregistre lui même dans le Registre
119 jpm 129
		modele = new Modele();
1468 jpm 130
 
131
		// Séquenceur (local au médiateur)
132
		sequenceur = new Sequenceur();
535 jp_milcent 133
 
60 jpm 134
		// Création du Viewport qui contient la disposition globale de l'application
135
		viewport = new Viewport();
136
		viewport.setLayout(new BorderLayout());
552 jp_milcent 137
 
60 jpm 138
		// Création des différents panneaux
139
	    creerPanneauNord();
140
	    creerPanneauOuest();
141
	    creerPanneauCentral();
358 jp_milcent 142
	    creerPanneauSud();
1210 cyprien 143
	    fenetreJournal = new FenetreJournal(this);
535 jp_milcent 144
 
145
		// Connection de l'utilisateur
146
		connecterUtilisateur(null, null);
147
 
1468 jpm 148
		// Creer la table qui gère le panneau de chargement/déchargement
149
		fileDAttenteChargement = new HashMap<Object, Integer>();
150
 
1509 jpm 151
		// Gestion de l'historique du navigateur
152
	    History.addValueChangeHandler(this);// Ajout du médiateur comme écouteur des changements de l'historique
153
		if ("".equals(History.getToken())) {
154
			History.newItem(MenuApplicationId.ACCUEIL);
155
		} else {
156
			History.fireCurrentHistoryState();
157
		}
158
 
60 jpm 159
		// Retour à GWT du Viewport une fois constuit
160
		RootPanel.get().add(viewport);
161
	}
162
 
156 jp_milcent 163
	//+----------------------------------------------------------------------------------------------------------------+
535 jp_milcent 164
	//												GESTION de l'I18N et du REGISTRE
165
	//+----------------------------------------------------------------------------------------------------------------+
582 jp_milcent 166
	protected static Constantes getI18nConstante() {
535 jp_milcent 167
		return GWT.create(Constantes.class);
168
	}
169
 
582 jp_milcent 170
	protected static ErrorMessages getI18nMessage() {
535 jp_milcent 171
		return GWT.create(ErrorMessages.class);
172
	}
173
 
174
	protected void initialiserRegistre() {
1107 jpm 175
		APropos apropos = new APropos();
907 jpm 176
 
1107 jpm 177
		Registry.register(RegistreId.APPLI_NOM, apropos.getAppliNom());
178
		Registry.register(RegistreId.APPLI_CODE, apropos.getAppliCode());
1108 jpm 179
		Registry.register(RegistreId.APPLI_VERSION, apropos.getAppliVersionCode());
180
		Registry.register(RegistreId.APPLI_VERSION_NOM, apropos.getAppliVersionNom());
1107 jpm 181
 
1023 jpm 182
		Registry.register(RegistreId.APPLI_DEVELOPPEURS, apropos.getDeveloppeurs());
183
		Registry.register(RegistreId.APPLI_TRADUCTEURS, apropos.getTraducteurs());
1417 jpm 184
		Registry.register(RegistreId.APPLI_TESTEURS, apropos.getTesteurs());
1023 jpm 185
		Registry.register(RegistreId.APPLI_LICENCE, apropos.getLicence());
1417 jpm 186
 
907 jpm 187
		Registry.register(RegistreId.APPLI_REVISION, apropos.getRevisionGlobale());
1549 jpm 188
		Registry.register(RegistreId.SERVICES_REVISION, apropos.getRevisionGlobaleServices());
907 jpm 189
		Registry.register(RegistreId.APPLI_COMPILATION_JAVA_VERSION, apropos.getVersionJavaCompilation());
190
		Registry.register(RegistreId.APPLI_COMPILATION_DATE_HEURE, apropos.getDateHeureCompilation());
535 jp_milcent 191
 
192
		Registry.register(RegistreId.CONFIG, new Configuration());
537 jp_milcent 193
		Registry.register(RegistreId.POPUP_CHARGEMENT, new PopupChargement(this));
766 jpm 194
		Registry.register(RegistreId.UTILISATEUR_COURANT, new Utilisateur());
535 jp_milcent 195
		Registry.register(RegistreId.PROJET_COURANT, new Projet());
196
	}
197
 
198
	//+----------------------------------------------------------------------------------------------------------------+
156 jp_milcent 199
	//												GESTION des PANNEAUX PRINCIPAUX
200
	//+----------------------------------------------------------------------------------------------------------------+
119 jpm 201
 
60 jpm 202
	private void creerPanneauNord() {
444 jp_milcent 203
		panneauNord = new EnteteVue(this);
60 jpm 204
 
205
		BorderLayoutData regionNord = new BorderLayoutData(LayoutRegion.NORTH, 100);
206
		regionNord.setCollapsible(true);
207
		regionNord.setFloatable(true);
208
		regionNord.setSplit(false);
209
		regionNord.setMargins(new Margins(5, 5, 0, 5));
210
 
211
		viewport.add(panneauNord, regionNord);
212
	}
213
 
214
	private void creerPanneauOuest() {
982 jpm 215
		panneauOuest = new NavigationVue(this);
60 jpm 216
 
1373 cyprien 217
		BorderLayoutData regionOuest = new BorderLayoutData(LayoutRegion.WEST, 241);
60 jpm 218
		regionOuest.setSplit(true);
219
		regionOuest.setCollapsible(true);
220
		regionOuest.setMargins(new Margins(5));
221
 
222
		viewport.add(panneauOuest, regionOuest);
223
	}
1369 cyprien 224
 
225
	public String getFiltreProjet() {
226
		return panneauOuest.getFiltre().getProjet();
227
	}
60 jpm 228
 
229
	private void creerPanneauCentral() {
444 jp_milcent 230
		panneauCentre = new ContenuVue(this);
60 jpm 231
 
232
		BorderLayoutData regionCentre = new BorderLayoutData(LayoutRegion.CENTER);
233
		regionCentre.setMargins(new Margins(5, 5, 5, 0));
234
 
235
		viewport.add(panneauCentre, regionCentre);
236
	}
358 jp_milcent 237
 
238
	private void creerPanneauSud() {
443 jp_milcent 239
		panneauSud = new StatutVue();
358 jp_milcent 240
 
369 jp_milcent 241
		BorderLayoutData regionSud = new BorderLayoutData(LayoutRegion.SOUTH, 20);
358 jp_milcent 242
		regionSud.setCollapsible(true);
243
		regionSud.setFloatable(true);
244
		regionSud.setSplit(false);
245
		regionSud.setMargins(new Margins(0));
246
 
247
		viewport.add(panneauSud, regionSud);
248
	}
60 jpm 249
 
369 jp_milcent 250
	public void actualiserPanneauCentral() {
251
		panneauCentre.layout();
252
	}
253
 
1210 cyprien 254
	public Rafraichissable obtenirFenetreJournal()	{
255
		return this.fenetreJournal;
256
	}
257
 
258
	public void ouvrirFenetreJournal()	{
259
		fenetreJournal.show();
260
	}
261
 
262
	public StatutVue obtenirPanneauSud()	{
263
		return this.panneauSud;
264
	}
265
 
156 jp_milcent 266
	//+----------------------------------------------------------------------------------------------------------------+
267
	//												GESTION du MENU
268
	//+----------------------------------------------------------------------------------------------------------------+
269
 
327 jp_milcent 270
	public void clicMenu(String codeMenuClique) {
1509 jpm 271
		boolean codeOk = true;
1210 cyprien 272
		if (codeMenuClique.equals(MenuApplicationId.ACCUEIL)) {
910 jpm 273
			afficherAccueil();
274
		} else if (codeMenuClique.equals(MenuApplicationId.PROJET)) {
1468 jpm 275
			selectionnerProjet(panneauCentre, null, null, false, null);
910 jpm 276
		} else if (codeMenuClique.equals(MenuApplicationId.STRUCTURE)) {
1324 gduche 277
			selectionnerStructure(panneauCentre, null, null);
553 jp_milcent 278
		} else if (codeMenuClique.equals(MenuApplicationId.COLLECTION)) {
1367 cyprien 279
			selectionnerCollection(panneauCentre, null, null, null);
553 jp_milcent 280
		} else if (codeMenuClique.equals(MenuApplicationId.PERSONNE)) {
1324 gduche 281
			selectionnerPersonne(panneauCentre, null, getProjetId(), null);
327 jp_milcent 282
		} else if (codeMenuClique.equals(MenuApplicationId.PUBLICATION)) {
1324 gduche 283
			selectionnerPublication(panneauCentre, null, null);
985 jpm 284
		} else if (codeMenuClique.equals(MenuApplicationId.COMMENTAIRE)) {
1367 cyprien 285
			selectionnerCommentaire(panneauCentre, null, null);
379 jp_milcent 286
		} else {
1562 jpm 287
			Log.debug(i18nM.nonImplemente(codeMenuClique));
1509 jpm 288
			codeOk = false;
60 jpm 289
		}
1509 jpm 290
 
291
		// Le code menu est valide
292
		if (codeOk == true) {
293
			// Sélection du menu
294
			panneauOuest.getMenu().selectionMenu(codeMenuClique);
295
			// Gestion de l'historique
1562 jpm 296
			if (requeteUrl == null) {
297
				History.newItem(codeMenuClique);
298
			} else {
299
				History.newItem(codeMenuClique+"?"+requeteUrl);
300
			}
1509 jpm 301
			// Rafraichissement du panneau central
302
			panneauCentre.layout();
303
		}
60 jpm 304
	}
1324 gduche 305
 
1468 jpm 306
	public void activerChargement(Object caller, String message) {
307
		if (fileDAttenteChargement.get(caller) == null) fileDAttenteChargement.put(caller, 1);
308
		else fileDAttenteChargement.put(caller, fileDAttenteChargement.get(caller)+1);
309
		activerChargement(message);
310
	}
311
 
312
	private void activerChargement(String message) {
313
		if (DEBUG_CHARGEMENT) System.out.println("[CHARGEMENT] ActiverChargement");
314
		if (DEBUG_CHARGEMENT) debugFileAttente();
1155 jpm 315
		afficherPopinChargement();
316
		panneauCentre.disable();
369 jp_milcent 317
		panneauSud.showBusy(i18nC.chargement()+" "+message);
358 jp_milcent 318
	}
319
 
1468 jpm 320
	public void desactiverChargement(Object caller) {
321
		if (fileDAttenteChargement.get(caller) == null) {
322
			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é.");
323
		}
324
		else fileDAttenteChargement.put(caller, fileDAttenteChargement.get(caller)-1);
325
 
326
		if (!chargementsEnCours()) desactiverChargement();
1513 jpm 327
		else if (DEBUG_CHARGEMENT) {
328
			System.out.println("[CHARGEMENT] Patienter, il y a encore un chargement en cours.");
329
			debugFileAttente();
330
		}
1468 jpm 331
	}
332
 
333
	private void desactiverChargement() {
334
		if (DEBUG_CHARGEMENT) System.out.println("[CHARGEMENT] Désactiver Chargement");
335
		if (DEBUG_CHARGEMENT) debugFileAttente();
358 jp_milcent 336
		masquerPopinChargement();
1155 jpm 337
		panneauCentre.enable();
358 jp_milcent 338
		panneauSud.clear();
339
	}
1468 jpm 340
 
341
	private boolean chargementsEnCours() {
342
		boolean chargementEnCours = false;
343
		Iterator<Object> it = fileDAttenteChargement.keySet().iterator();
344
		while (it.hasNext() && !chargementEnCours) {
345
			chargementEnCours = (fileDAttenteChargement.get(it.next()) > 0);
346
		}
347
		return chargementEnCours;
348
	}
349
 
350
	private void debugFileAttente() {
351
		System.out.println("[CHARGEMENT]--< StackTrace >------------------------------------------------------");
352
		if (fileDAttenteChargement.size() == 0) System.out.println("(Empty)");
353
		Iterator<Object> it = fileDAttenteChargement.keySet().iterator();
354
		while (it.hasNext()) {
355
			Object o = it.next();
1513 jpm 356
			System.out.println("      ["+o+"] = "+fileDAttenteChargement.get(o));
1468 jpm 357
		}
358
	}
646 jp_milcent 359
 
156 jp_milcent 360
	//+----------------------------------------------------------------------------------------------------------------+
361
	//												GESTION DES FENÊTRES
362
	//+----------------------------------------------------------------------------------------------------------------+
60 jpm 363
 
61 jpm 364
	public void ouvrirAide() {
365
		AideFenetre aideFenetre = new AideFenetre();
366
		aideFenetre.show();
66 jpm 367
		// FIXME : apparament le fade In/Fade Out pose problème sur les navigateurs...
368
		//aideFenetre.el().fadeIn(FxConfig.NONE);
61 jpm 369
	}
370
 
371
	public void ouvrirParametres() {
1023 jpm 372
		AproposFenetre parametresFenetre = new AproposFenetre();
66 jpm 373
		parametresFenetre.show();
61 jpm 374
	}
375
 
376
	public void ouvrirIdentification() {
1017 jpm 377
		fenetreIdentification = new IdentificationFenetre(this);
358 jp_milcent 378
		fenetreIdentification.show();
61 jpm 379
	}
380
 
989 jpm 381
	public void ouvrirUrlExterne(String id) {
61 jpm 382
		if (id.equals(ComposantId.MENU_CEL)) {
989 jpm 383
			Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getUrl("cel"), "Carnet en ligne", "");
384
		} else if (id.equals(ComposantId.MENU_BOGUE)) {
385
			Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getUrl("bogue"), "Bogue", "");
386
		} else if (id.equals(ComposantId.MENU_COMMENTAIRE)) {
387
			Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getUrl("commentaire"), "Commentaire", "");
61 jpm 388
		}
389
	}
390
 
898 gduche 391
	public void afficherFenetreLicence(IdentificationFenetre vue)	{
1509 jpm 392
		new LicenceFenetre(vue);
898 gduche 393
	}
394
 
395
	public void accepterLicence(Rafraichissable vue)	{
396
		modele.accepterLicence(vue);
397
	}
156 jp_milcent 398
	//+----------------------------------------------------------------------------------------------------------------+
399
	//												GESTION de l'UTILISATEUR et de l'IDENTIFICATION
400
	//+----------------------------------------------------------------------------------------------------------------+
245 jp_milcent 401
	/**
402
	 * Retourne l'identifiant de l'utilisateur courrant de l'application.
403
	 */
156 jp_milcent 404
	public String getUtilisateurId() {
277 jp_milcent 405
		String id = null;
406
		Utilisateur utilisateurCourant = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
407
		if (!utilisateurCourant.getId().equals("")) {
408
			id = utilisateurCourant.getId();
409
		}
410
		return id;
156 jp_milcent 411
	}
412
 
912 jpm 413
	public Utilisateur getUtilisateur() {
414
		Utilisateur utilisateurCourant = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
415
		return utilisateurCourant;
416
	}
417
 
65 jpm 418
	public void connecterUtilisateur(String login, String mdp) {
277 jp_milcent 419
		modele.connecterUtilisateur(this, login, mdp);
64 jpm 420
	}
421
 
65 jpm 422
	public void deconnecterUtilisateur() {
277 jp_milcent 423
		modele.deconnecterUtilisateur(this);
64 jpm 424
	}
65 jpm 425
 
932 jpm 426
	public void repandreEtatIdentification(Utilisateur utilisateur) {
156 jp_milcent 427
		// Mise à jour du registre
277 jp_milcent 428
		Registry.register(RegistreId.UTILISATEUR_COURANT, utilisateur);
932 jpm 429
		// Propagation de l'information de mise à jour de l'utilisateur
430
		repandreInfoMiseAJourUtilisateur();
431
	}
432
 
433
	public void repandreInfoMiseAJourUtilisateur() {
912 jpm 434
		// Création de l'information de mise à jour de l'utilisateur
435
		Information info = new Information("maj_utilisateur");
436
 
437
		// Rafraichissement de la fenêtre d'Identification
941 jpm 438
		if (fenetreIdentification != null && fenetreIdentification.isVisible()) {
912 jpm 439
			fenetreIdentification.rafraichir(info);
440
		}
898 gduche 441
 
912 jpm 442
		// Rafraichissement du panneau Nord
443
		panneauNord.rafraichir(info);
1292 cyprien 444
 
912 jpm 445
		// Rafraichissement du panneau Centre
446
		if (panneauCentre != null) {
447
			panneauCentre.rafraichir(info);
932 jpm 448
		}
912 jpm 449
	}
1292 cyprien 450
 
912 jpm 451
	public void modifierUtilisateur()	{
452
		Utilisateur utilisateurCourant = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
453
		panneauNord.rafraichir(utilisateurCourant);
454
		modele.modifierUtilisateur(this, utilisateurCourant);
61 jpm 455
	}
1292 cyprien 456
 
156 jp_milcent 457
	//+----------------------------------------------------------------------------------------------------------------+
447 jp_milcent 458
	//												GESTION DES VALEURS ET LISTES
459
	//+----------------------------------------------------------------------------------------------------------------+
1367 cyprien 460
 
461
	/** Cette méthode est un "wrapper" **/
1324 gduche 462
	public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, String listeId, Sequenceur sequenceur)	{
463
		obtenirListeValeurEtRafraichir(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), sequenceur);
1292 cyprien 464
	}
1367 cyprien 465
 
1324 gduche 466
	public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, int listeId, Sequenceur sequenceur)	{
1367 cyprien 467
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  ValeurListe");
1324 gduche 468
		Integer numeroSequence = null;
469
		if (sequenceur != null)	{
470
			numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
471
			vueARafraichir = sequenceur;
472
		}
473
		modele.obtenirListeValeurs(vueARafraichir, listeId, numeroSequence);
453 jp_milcent 474
	}
1367 cyprien 475
 
1324 gduche 476
	public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, String nomListe, boolean pagination, String recherche, int start, int nbElements, Sequenceur sequenceur)	{
1367 cyprien 477
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  ValeurListe");
1324 gduche 478
		Integer numeroSequence = null;
479
		if (sequenceur != null)	{
480
			numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
481
			vueARafraichir = sequenceur;
482
		}
483
		modele.obtenirListeValeurs(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(nomListe), pagination, recherche, start, nbElements, numeroSequence);
484
	}
1367 cyprien 485
 
486
	public void obtenirValeurEtRafraichir(Rafraichissable vueARafraichir, String listeId, String identifiantValeur, Sequenceur sequenceur)	{
487
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  ValeurListe");
1324 gduche 488
		Integer numeroSequence = null;
489
		if (sequenceur != null)	{
1367 cyprien 490
			numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
491
			vueARafraichir = sequenceur;
1324 gduche 492
		}
1373 cyprien 493
		modele.obtenirValeur(vueARafraichir, "identifiant", ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), identifiantValeur, numeroSequence);
453 jp_milcent 494
	}
1367 cyprien 495
 
496
	public void obtenirListeRegionsEtRafraichir(Rafraichissable vueARafraichir, String strListeId, String strPays)	{
497
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  obtenirListeRegions");
498
		modele.obtenirListeRegion(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(strListeId), strPays+".__");
453 jp_milcent 499
	}
1367 cyprien 500
 
447 jp_milcent 501
	//+----------------------------------------------------------------------------------------------------------------+
910 jpm 502
	//												GESTION des APPLETS de l'ACCUEIL
503
	//+----------------------------------------------------------------------------------------------------------------+
504
 
505
	public void afficherAccueil() {
1210 cyprien 506
		if (!(panneauCentre.getContenu() instanceof AccueilVue)) {
910 jpm 507
			panneauCentre.removeAll();
508
			panneauCentre.add(new AccueilVue(this));
509
		}
1210 cyprien 510
		else {
511
			desactiverChargement();
512
		}
910 jpm 513
	}
514
 
515
	//+----------------------------------------------------------------------------------------------------------------+
447 jp_milcent 516
	//												GESTION des PROJETS
517
	//+----------------------------------------------------------------------------------------------------------------+
518
 
1613 aurelien 519
	public void afficherFormProjet(String projetId) {
520
		final FenetreForm fenetre = new FenetreForm("");
521
		ProjetForm projetForm = new ProjetForm(this, projetId)  {
522
			@Override
523
			public void surFermetureFormulaire() {
524
				fenetre.hide();
525
			}
526
		};
527
		projetForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu();
528
		fenetre.add(projetForm);
529
		fenetre.show();
928 jpm 530
	}
531
 
532
	public void afficherListeProjets(ProjetListe projetsACharger)	{
533
		if (!(panneauCentre.getContenu() instanceof ProjetVue))	{
534
			panneauCentre.removeAll();
535
			panneauCentre.add(new ProjetVue(this));
536
			panneauCentre.setId(ComposantId.PANNEAU_PROJET_LISTE);
537
			panneauCentre.layout();
538
		}
539
 
540
		panneauCentre.getContenu().rafraichir(projetsACharger);
1088 gduche 541
		mettreFiltreAJour(projetsACharger);
928 jpm 542
	}
543
 
1088 gduche 544
	public void mettreFiltreAJour(ProjetListe projetsACharger) {
545
		panneauOuest.getFiltre().rafraichir(projetsACharger);
546
	}
547
 
548
	public void mettreFiltreAJour(List<Projet> projetsACharger) {
549
		panneauOuest.getFiltre().rafraichir(projetsACharger);
550
	}
551
 
928 jpm 552
	public void clicListeProjet(Projet projet) {
553
		panneauCentre.getContenu().rafraichir(projet);
554
	}
555
 
556
	public void clicSupprimerProjet(final List<Projet> projetListe) {
557
		if (projetListe.size() <= 0) {
558
			MessageBox.alert("Attention", "Vous devez sélectionner un projet", null);
559
		} else {
560
			String message = "Voulez-vous vraiment supprimer ces projets ?";
561
			if (projetListe.size() == 1) {
562
				message = "Voulez-vous vraiment supprimer ce projet ?";
563
			}
564
 
565
			final Listener<MessageBoxEvent> listenerSuppression = new Listener<MessageBoxEvent>() {
566
				public void handleEvent(MessageBoxEvent ce) {
567
					Dialog dialog = (Dialog) ce.getComponent();
568
				    Button btn = ce.getButtonClicked();
569
 
1680 raphael 570
				    if (btn.getHtml().equals(dialog.yesText)) {
928 jpm 571
				    	modele.supprimerProjet(panneauCentre.getContenu(), projetListe);
572
				    }
573
				}
574
			};
575
 
576
			MessageBox.confirm("Supprimer un projet", message, listenerSuppression);
577
		}
578
 
579
	}
580
 
581
	public void clicModifierProjet(List<Projet> projetsSelectionnes) {
582
		if (projetsSelectionnes.size() == 0) {
1210 cyprien 583
			InfoLogger.display("Information", "Veuillez sélectionner un projet.");
928 jpm 584
		} else if (projetsSelectionnes.size() > 1) {
1210 cyprien 585
			InfoLogger.display("Information", "Veuillez sélectionner un seul projet à la fois.");
928 jpm 586
		} else if (projetsSelectionnes.size() == 1) {
587
			afficherFormProjet(projetsSelectionnes.get(0).getId());
588
		} else {
1210 cyprien 589
			InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierProjet() du Médiateur.");
928 jpm 590
		}
591
	}
592
 
593
	public void clicAjouterProjet() {
594
		afficherFormProjet(null);
595
	}
596
 
1329 cyprien 597
	/****************************************************************************************************
598
	/** selectionnerProjet(Rafraichissable vueARafraichir, String recherche, int start, int nbElements)
599
	/****************************************************************************************************
600
	 * Action :
601
	 * --------
602
	 * -	Récupère un nombre défini de projets en s'aidant du nom partiel ou complet du projet.
603
	 *
604
	 * Description des paramètres :
605
	 * ----------------------------
606
	 *  -	'vueARafraichir' référence l'objet à mettre à jour après réception des données.
607
	 *  -	'recherche' est une chaîne de caractères représentant tout ou partie du nom d'un projet.
608
	 *  		Si la chaîne est vide, alors tous les projets sont recherchés.
609
	 *  -	'start' et 'nbElements' sont les paramètres indispensables à la pagination. 'start'
610
	 *  		est le paramètre qui décrit le numéro du tuple de départ et 'nbElements' le nombre
611
	 *  		d'éléments à collecter.
612
	 *
613
	 * Préconditions :
614
	 * ---------------
615
	 *  -	'vueARafraichir' doit être non NULL et référencer un objet implémentant l'interface
616
	 *  		'Rafraichissable'
617
	 *  -	'recherche' doit être non NULL.
618
	 *  -	'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro.
619
	 *
620
	 *****************************************************************************************************/
1367 cyprien 621
	public void selectionnerProjet(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) {
622
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Projet");
623
		Integer numeroSequence = null;
624
		if (sequenceur != null)	{
625
			numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
626
			vueARafraichir = sequenceur;
627
		}
628
		modele.selectionnerProjet(vueARafraichir, recherche, start, nbElements, numeroSequence);
1329 cyprien 629
	}
630
 
1367 cyprien 631
	/** Cette méthode est un "wrapper" **/
1468 jpm 632
	public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, String formatRetour, boolean paginationProgressive, Sequenceur sequenceur) {
633
		selectionnerProjet(vueARafraichir, projetId, null, 0, this.nbElements, formatRetour, paginationProgressive, sequenceur);
928 jpm 634
	}
1045 gduche 635
 
1468 jpm 636
	public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, String nom, int start, int nbElements, String formatRetour, boolean paginationProgressive, Sequenceur sequenceur) {
1367 cyprien 637
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Projet");
638
		Integer numeroSequence = null;
639
		if (sequenceur != null)	{
640
			numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
641
			vueARafraichir = sequenceur;
642
		}
1468 jpm 643
		modele.selectionnerProjet(vueARafraichir, projetId, nom, start, nbElements, formatRetour, paginationProgressive, numeroSequence);
1045 gduche 644
	}
928 jpm 645
 
1367 cyprien 646
	/** AJOUTER **/
928 jpm 647
	public void ajouterProjet(Rafraichissable vueARafraichir, Projet projetCollecte) {
648
		modele.ajouterProjet(vueARafraichir, projetCollecte);
649
	}
650
 
1367 cyprien 651
	/** MODIFIER **/
928 jpm 652
	public void modifierProjet(Rafraichissable vueARafraichir, Projet projetCollecte) {
653
		modele.modifierProjet(vueARafraichir, projetCollecte);
654
	}
655
 
656
	//+----------------------------------------------------------------------------------------------------------------+
657
	// SELECTION : projet
447 jp_milcent 658
	/**
659
	 * Retourne l'identifiant du projet courrant de l'application.
660
	 */
661
	public String getProjetId() {
662
		String id = null;
663
		Projet projetCourant = (Projet) Registry.get(RegistreId.PROJET_COURANT);
664
		if (projetCourant != null && !projetCourant.getId().equals("")) {
665
			id = projetCourant.getId();
666
		}
667
		return id;
668
	}
928 jpm 669
 
447 jp_milcent 670
	public void selectionnerProjetCourant(Projet projetSelectionne) {
671
		Registry.register(RegistreId.PROJET_COURANT, projetSelectionne);
1109 jpm 672
		if (panneauCentre.getContenu() instanceof AccueilVue)	{
673
			desactiverChargement();
674
		} else if (panneauCentre.getContenu() instanceof ProjetVue)	{
1468 jpm 675
			selectionnerProjet(panneauCentre.getContenu(), null, null, false, null);
646 jp_milcent 676
		} else if (panneauCentre.getContenu() instanceof StructureVue)	{
1324 gduche 677
			selectionnerStructure(panneauCentre.getContenu(), null, null);
646 jp_milcent 678
		} else if (panneauCentre.getContenu() instanceof CollectionVue)	{
1367 cyprien 679
			selectionnerCollection(panneauCentre.getContenu(), null, null, null);
928 jpm 680
		} else if (panneauCentre.getContenu() instanceof PersonneVue) {
1324 gduche 681
			selectionnerPersonne(panneauCentre.getContenu(), null, getProjetId(), null);
928 jpm 682
		} else if (panneauCentre.getContenu() instanceof PublicationVue) {
1324 gduche 683
			selectionnerPublication(panneauCentre.getContenu(), null, null);
987 jpm 684
		} else if (panneauCentre.getContenu() instanceof CommentaireVue) {
1367 cyprien 685
			selectionnerCommentaire(panneauCentre.getContenu(), null, null);
447 jp_milcent 686
		}
687
	}
688
 
928 jpm 689
 
447 jp_milcent 690
	//+----------------------------------------------------------------------------------------------------------------+
691
	//												GESTION DES STRUCTURES
692
	//+----------------------------------------------------------------------------------------------------------------+
693
 
453 jp_milcent 694
	public void afficherListeStructures(StructureListe structuresACharger) {
646 jp_milcent 695
		if (!(panneauCentre.getContenu() instanceof StructureVue))	{
626 gduche 696
			panneauCentre.removeAll();
646 jp_milcent 697
			panneauCentre.add(new StructureVue(this));
626 gduche 698
		}
646 jp_milcent 699
		panneauCentre.getContenu().rafraichir(structuresACharger);
453 jp_milcent 700
	}
701
 
580 jp_milcent 702
	public void afficherFormStructure(String structureId) {
641 jp_milcent 703
		String mode = Formulaire.MODE_AJOUTER;
580 jp_milcent 704
		if (structureId != null) {
641 jp_milcent 705
			mode = Formulaire.MODE_MODIFIER;
580 jp_milcent 706
		}
707
 
1613 aurelien 708
		final FenetreForm fenetre = new FenetreForm("");
1324 gduche 709
		Sequenceur sequenceur = new Sequenceur();
1613 aurelien 710
		StructureForm structureForm = new StructureForm(this, mode, sequenceur) {
711
			@Override
712
			public void surFermetureFormulaire() {
713
				fenetre.hide();
714
			}
715
		};
716
		structureForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu();
717
		fenetre.add(structureForm);
718
		fenetre.show();
580 jp_milcent 719
 
641 jp_milcent 720
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
1324 gduche 721
			selectionnerStructure(structureForm, structureId, sequenceur);
722
			selectionnerStructureAPersonne(structureForm, structureId, StructureAPersonne.ROLE_EQUIPE, sequenceur);
580 jp_milcent 723
		}
724
 
725
		panneauCentre.layout();
726
	}
727
 
447 jp_milcent 728
	public void clicListeStructure(Structure structure) {
646 jp_milcent 729
		panneauCentre.getContenu().rafraichir(structure);
609 jp_milcent 730
		if (structure != null && structure.getPersonnel() == null) {
1324 gduche 731
			selectionnerStructureAPersonne(panneauCentre.getContenu(), structure.getId(), StructureAPersonne.ROLE_EQUIPE, null);
919 jpm 732
		}
447 jp_milcent 733
	}
734
 
735
	public void clicAjouterStructure() {
580 jp_milcent 736
		afficherFormStructure(null);
447 jp_milcent 737
	}
738
 
739
	public void clicModifierStructure(List<Structure> structureSelection) {
740
		if (structureSelection.size() == 0) {
1210 cyprien 741
			InfoLogger.display("Information", "Veuillez sélectionner une structure.");
447 jp_milcent 742
		} else if (structureSelection.size() > 1) {
1210 cyprien 743
			InfoLogger.display("Information", "Veuillez sélectionner une seule structure à la fois.");
447 jp_milcent 744
		} else if (structureSelection.size() == 1) {
609 jp_milcent 745
			afficherFormStructure(structureSelection.get(0).getId());
447 jp_milcent 746
		} else {
1210 cyprien 747
			InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierStructure() du Médiateur.");
447 jp_milcent 748
		}
749
	}
750
 
751
	public void clicSupprimerStructure(final Rafraichissable vue, final List<Structure> structureSelection) {
752
		if (structureSelection.size() == 0) {
1210 cyprien 753
			InfoLogger.display("Information", "Veuillez sélectionner une structure.");
447 jp_milcent 754
		} else if(structureSelection.size() > 0) {
609 jp_milcent 755
			String titre = "Supprimer des structures";
447 jp_milcent 756
			String message = "Êtes vous sur de vouloir supprimer les structures sélectionnées ?";
757
			if (structureSelection.size() == 1) {
609 jp_milcent 758
				titre = "Supprimer une structure";
447 jp_milcent 759
				message = "Êtes vous sur de vouloir supprimer la structure sélectionnée ?";
760
			}
761
 
502 gduche 762
			final Listener<MessageBoxEvent> suppressionEcouteur = new Listener<MessageBoxEvent>() {
763
				public void handleEvent(MessageBoxEvent ce) {
764
					Dialog dialog = (Dialog) ce.getComponent();
765
					Button btn = ce.getButtonClicked();
453 jp_milcent 766
 
1680 raphael 767
					if (btn.getHtml().equals(dialog.yesText))	{
453 jp_milcent 768
						String idStr = "" ;
769
						for(int i = 0 ; i < structureSelection.size() ; i++) {
609 jp_milcent 770
							idStr += structureSelection.get(i).getId()+",";
453 jp_milcent 771
						}
923 jpm 772
						supprimerStructure(vue, idStr);
453 jp_milcent 773
					}
774
				}
775
			};
447 jp_milcent 776
 
609 jp_milcent 777
			MessageBox.confirm(titre, message, suppressionEcouteur);
447 jp_milcent 778
		} else {
1210 cyprien 779
			InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerStructure() du Médiateur.");
447 jp_milcent 780
		}
781
	}
1329 cyprien 782
 
783
	/** selectionnerStructure(Rafraichissable vueARafraichir, String recherche, int start, int nbElements)
784
	 * Action :
785
	 * --------
786
	 * -	Récupère un nombre défini de structures en s'aidant du nom partiel ou complet de la structure.
787
	 *
788
	 * Description des paramètres :
789
	 * ----------------------------
790
	 *  -	'vueARafraichir' référence l'objet à mettre à jour après réception des données.
791
	 *  -	'recherche' est une chaîne de caractères représentant tout ou partie du nom d'une structure.
792
	 *  		Si la chaîne est vide, alors toutes les structures sont recherchées.
793
	 *  -	'start' et 'nbElements' sont les paramètres indispensables à la pagination. 'start'
794
	 *  		est le paramètre qui décrit le numéro du tuple de départ et 'nbElements' le nombre
795
	 *  		d'éléments à collecter.
796
	 *
797
	 * Préconditions :
798
	 * ---------------
799
	 *  -	'vueARafraichir' doit être non NULL et référencer un objet implémentant l'interface
800
	 *  		'Rafraichissable'
801
	 *  -	'recherche' doit être non NULL.
802
	 *  -	'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro.
803
	 *
1526 jpm 804
	 */
1367 cyprien 805
	public void selectionnerStructure(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) {
1526 jpm 806
		if (Mediateur.DEBUG) {
807
			System.out.println("MEDIATEUR - selectionner  Structure");
808
		}
1367 cyprien 809
		Integer seqId = null;
1526 jpm 810
		if (sequenceur != null)	{
1367 cyprien 811
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
812
			vueARafraichir = sequenceur;
813
		}
1329 cyprien 814
		modele.selectionnerStructure(vueARafraichir, recherche, start, nbElements, seqId);
815
	}
447 jp_milcent 816
 
1324 gduche 817
	public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, Sequenceur sequenceur) {
1526 jpm 818
		if (Mediateur.DEBUG) {
819
			System.out.println("MEDIATEUR - selectionner  Structure");
820
		}
1324 gduche 821
		Integer seqId = null;
1526 jpm 822
		if (sequenceur != null)	{
1324 gduche 823
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
824
			vueARafraichir = sequenceur;
825
		}
1633 aurelien 826
 
1324 gduche 827
		modele.selectionnerStructure(vueARafraichir, getProjetId(), structureId, null, 0, nbElements, seqId);
447 jp_milcent 828
	}
829
 
1367 cyprien 830
	public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, String projetId, String nom, int start, int nbElements, Sequenceur sequenceur)	{
1526 jpm 831
		if (Mediateur.DEBUG) {
832
			System.out.println("MEDIATEUR - selectionner  Structure");
833
		}
1367 cyprien 834
		Integer seqId = null;
1526 jpm 835
		if (sequenceur != null)	{
1367 cyprien 836
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
837
			vueARafraichir = sequenceur;
838
		}
839
		modele.selectionnerStructure(vueARafraichir, getProjetId(), structureId, nom, start, nbElements, seqId);
1040 gduche 840
	}
841
 
1526 jpm 842
	public void selectionnerStructureAvecPaginationProgressive(Rafraichissable vueARafraichir, String structureId, String projetId, String nom, String formatRetour, int start, int nbElements, Sequenceur sequenceur)	{
843
		if (Mediateur.DEBUG) {
844
			System.out.println("MEDIATEUR - selectionner  Structure");
845
		}
846
		Integer seqId = null;
847
		if (sequenceur != null)	{
848
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
849
			vueARafraichir = sequenceur;
850
		}
851
		modele.selectionnerStructureAvecPaginationProgressive(vueARafraichir, getProjetId(), structureId, nom, formatRetour, start, nbElements, seqId);
852
	}
853
 
1367 cyprien 854
	public void selectionnerStructureParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) {
1526 jpm 855
		if (Mediateur.DEBUG) {
856
			System.out.println("MEDIATEUR - selectionner  Structure");
857
		}
1367 cyprien 858
		Integer seqId = null;
1526 jpm 859
		if (sequenceur != null)	{
1367 cyprien 860
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
861
			vueARafraichir = sequenceur;
862
		}
863
		modele.selectionnerStructure(vueARafraichir, projetId, null, null, 0, -1, seqId);
775 jpm 864
	}
865
 
1367 cyprien 866
	/** AJOUTER **/
769 jpm 867
	public void ajouterStructure(Rafraichissable vueARafraichir, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
868
		modele.ajouterStructure(vueARafraichir, structure, conservation, valorisation);
447 jp_milcent 869
	}
870
 
1367 cyprien 871
	/** MODIFIER **/
769 jpm 872
	public void modifierStructure(Rafraichissable vueARafraichir, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
873
		modele.modifierStructure(vueARafraichir, structureId, structure, conservation, valorisation);
447 jp_milcent 874
	}
453 jp_milcent 875
 
1367 cyprien 876
	/** SUPPRIMER **/
453 jp_milcent 877
	public void supprimerStructure(Rafraichissable vueARafraichir, String IdentifiantsStructureSepareParVirgule) {
769 jpm 878
		modele.supprimerStructure(vueARafraichir, IdentifiantsStructureSepareParVirgule);
453 jp_milcent 879
	}
880
 
447 jp_milcent 881
	//+----------------------------------------------------------------------------------------------------------------+
882
	// GESTION de la relation STRUCTURE A PERSONNE
1468 jpm 883
 
884
	public void selectionnerStructureAPersonne(Rafraichissable vueARafraichir, String structureId, String roleId, String nom, int start, int nbElements, Sequenceur sequenceur) {
885
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  StructureAPersonne");
886
		Integer seqId = null;
887
		if (sequenceur!=null)	{
888
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
889
			vueARafraichir = sequenceur;
890
		}
891
		modele.selectionnerStructureAPersonne(vueARafraichir, structureId, roleId, nom, start, nbElements, seqId);
892
	}
893
 
1324 gduche 894
	public void selectionnerStructureAPersonne(Rafraichissable vueARafraichir, String structureId, String roleId, Sequenceur sequenceur) {
1367 cyprien 895
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  StructureAPersonne");
1324 gduche 896
		Integer seqId = null;
1367 cyprien 897
		if (sequenceur!=null)	{
1324 gduche 898
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
899
			vueARafraichir = sequenceur;
900
		}
901
		modele.selectionnerStructureAPersonne(vueARafraichir, structureId, roleId, seqId);
447 jp_milcent 902
	}
903
 
1367 cyprien 904
	/** AJOUTER **/
769 jpm 905
	public void ajouterStructureAPersonne(Rafraichissable vueARafraichir, String structureId, StructureAPersonneListe personnelAjoute) {
453 jp_milcent 906
		if (personnelAjoute != null && personnelAjoute.size() > 0) {
907
			for (Iterator<String> it = personnelAjoute.keySet().iterator(); it.hasNext();) {
769 jpm 908
				modele.ajouterStructureAPersonne(vueARafraichir, structureId, (StructureAPersonne) personnelAjoute.get(it.next()));
453 jp_milcent 909
			}
910
		}
911
	}
912
 
1367 cyprien 913
	/** MODIFIER **/
769 jpm 914
	public void modifierStructureAPersonne(Rafraichissable vueARafraichir, StructureAPersonneListe personnelModifie) {
447 jp_milcent 915
		if (personnelModifie != null && personnelModifie.size() > 0) {
916
			for (Iterator<String> it = personnelModifie.keySet().iterator(); it.hasNext();) {
769 jpm 917
				modele.modifierStructureAPersonne(vueARafraichir, (StructureAPersonne) personnelModifie.get(it.next()));
447 jp_milcent 918
			}
919
		}
920
	}
921
 
1367 cyprien 922
	/** SUPPRIMER **/
769 jpm 923
	public void supprimerStructureAPersonne(Rafraichissable vueARafraichir, StructureAPersonneListe personnelSupprime) {
447 jp_milcent 924
		if (personnelSupprime != null && personnelSupprime.size() > 0) {
769 jpm 925
			String idStructureAPersonneSepareParVirgule = "" ;
923 jpm 926
			Iterator<String> it = personnelSupprime.keySet().iterator();
927
			while (it.hasNext()) {
901 jpm 928
				idStructureAPersonneSepareParVirgule += personnelSupprime.get(it.next()).getId();
923 jpm 929
				idStructureAPersonneSepareParVirgule += (it.hasNext()) ? "," : "";
447 jp_milcent 930
			}
923 jpm 931
			supprimerStructureAPersonne(vueARafraichir, idStructureAPersonneSepareParVirgule);
447 jp_milcent 932
		}
933
	}
923 jpm 934
 
935
	public void supprimerStructureAPersonne(Rafraichissable vueARafraichir, String idStructureAPersonneSeparesParVirgule) {
936
		modele.supprimerStructureAPersonne(vueARafraichir, idStructureAPersonneSeparesParVirgule);
937
	}
938
 
939
	public void supprimerStructureAPersonne(final Rafraichissable vueARafraichir, final List<Structure> structuresListe) {
940
		if (structuresListe.size() != 0) {
941
			String idStructureSepareParVirgule = "" ;
942
			Iterator<Structure> it = structuresListe.iterator();
943
			while (it.hasNext()) {
944
				Structure structure = it.next();
945
				idStructureSepareParVirgule += structure.getId();
946
				idStructureSepareParVirgule += it.hasNext() ? "," : "";
947
			}
948
			supprimerStructureAPersonne(vueARafraichir, idStructureSepareParVirgule);
949
		}
950
	}
951
 
447 jp_milcent 952
	//+----------------------------------------------------------------------------------------------------------------+
953
	//												GESTION des COLLECTIONS
954
	//+----------------------------------------------------------------------------------------------------------------+
955
 
453 jp_milcent 956
	public void afficherListeCollections(CollectionListe collectionsACharger) {
646 jp_milcent 957
		if (!(panneauCentre.getContenu() instanceof CollectionVue)) {
626 gduche 958
			panneauCentre.removeAll();
646 jp_milcent 959
			panneauCentre.add(new CollectionVue(this));
960
		}
626 gduche 961
 
646 jp_milcent 962
		panneauCentre.getContenu().rafraichir(collectionsACharger);
453 jp_milcent 963
	}
964
 
641 jp_milcent 965
	public void afficherFormCollection(String collectionId) {
1613 aurelien 966
		final FenetreForm fenetre = new FenetreForm("");
967
		CollectionForm collectionForm = new CollectionForm(this, collectionId)  {
968
			@Override
969
			public void surFermetureFormulaire() {
970
				fenetre.hide();
971
			}
972
		};
973
		collectionForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu();
974
		fenetre.add(collectionForm);
975
		fenetre.show();
641 jp_milcent 976
	}
977
 
453 jp_milcent 978
	public void clicListeCollection(Collection collectionCliquee) {
646 jp_milcent 979
		panneauCentre.getContenu().rafraichir(collectionCliquee);
883 jpm 980
		if (collectionCliquee != null) {
1468 jpm 981
			selectionnerCollectionAPersonne(panneauCentre.getContenu(), collectionCliquee.getId(), null, sequenceur);
982
			selectionnerCollectionAPublication(panneauCentre.getContenu(), collectionCliquee.getId(), sequenceur);
983
			selectionnerCollectionACommentaire(panneauCentre.getContenu(), collectionCliquee.getId(), sequenceur);
883 jpm 984
		}
453 jp_milcent 985
	}
986
 
447 jp_milcent 987
	public void clicAjouterCollection() {
775 jpm 988
		afficherFormCollection(null);
447 jp_milcent 989
	}
990
 
991
	public void clicModifierCollection(List<Collection> selection) {
641 jp_milcent 992
		if (selection.size() == 0) {
1210 cyprien 993
			InfoLogger.display("Information", "Veuillez sélectionner une collection.");
641 jp_milcent 994
		} else if (selection.size() > 1) {
1210 cyprien 995
			InfoLogger.display("Information", "Veuillez sélectionner une seule collection à la fois.");
641 jp_milcent 996
		} else if (selection.size() == 1) {
997
			afficherFormCollection(selection.get(0).getId());
998
		} else {
1210 cyprien 999
			InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierCollection() du Médiateur.");
641 jp_milcent 1000
		}
447 jp_milcent 1001
	}
1002
 
968 jpm 1003
	public void clicSupprimerCollection(CollectionListeVue collectionListeVue, final List<Collection> collectionsASupprimer) {
1004
		if (collectionsASupprimer.size() <= 0) {
1005
			MessageBox.alert("Attention", "Vous devez sélectionner au moins une collection", null);
1006
		} else {
1007
			String message = "Voulez-vous vraiment supprimer ces collections ?";
1008
			if (collectionsASupprimer.size() == 1) {
1009
				message = "Voulez-vous vraiment supprimer cette collection ?";
1010
			}
1011
 
1012
			final Listener<MessageBoxEvent> listenerSuppression = new Listener<MessageBoxEvent>() {
1013
				public void handleEvent(MessageBoxEvent ce) {
1014
					Dialog dialog = (Dialog) ce.getComponent();
1015
				    Button btn = ce.getButtonClicked();
1016
 
1680 raphael 1017
				    if (btn.getHtml().equals(dialog.yesText)) {
968 jpm 1018
				    	supprimerCollection(panneauCentre.getContenu(), collectionsASupprimer);
1019
				    }
1020
				}
1021
			};
1022
 
1023
			MessageBox.confirm("Supprimer une collection", message, listenerSuppression);
1024
		}
447 jp_milcent 1025
	}
1026
 
1367 cyprien 1027
	/** Cette méthode est un "wrapper" **/
1028
	public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId, String nom, Sequenceur sequenceur) {
1029
		selectionnerCollection(vueARafraichir, collectionId, nom, 0, nbElements, sequenceur);
453 jp_milcent 1030
	}
1031
 
1367 cyprien 1032
	public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId, String nom, int start, int nbElements, Sequenceur sequenceur)	{
1033
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Collection");
1034
		Integer seqId = null;
1035
		if (sequenceur!=null)	{
1036
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1037
			vueARafraichir = sequenceur;
1038
		}
1039
		modele.selectionnerCollection(vueARafraichir, getProjetId(), collectionId, nom, start, nbElements, seqId);
1041 gduche 1040
	}
1041
 
1367 cyprien 1042
	public void selectionnerCollectionParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) {
1043
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Collection");
1044
		Integer seqId = null;
1045
		if (sequenceur!=null)	{
1046
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1047
			vueARafraichir = sequenceur;
1048
		}
1049
		modele.selectionnerCollection(vueARafraichir, projetId, null, null, 0, -1, seqId);
775 jpm 1050
	}
1051
 
1329 cyprien 1052
	/****************************************************************************************************
1053
	/** selectionnerCollection(Rafraichissable vueARafraichir, String recherche, int start, int nbElements)
1054
	/****************************************************************************************************
1055
	 * Action :
1056
	 * --------
1057
	 * -	Récupère un nombre défini de collections en s'aidant du nom partiel ou complet de la collection.
1058
	 *
1059
	 * Description des paramètres :
1060
	 * ----------------------------
1061
	 *  -	'vueARafraichir' référence l'objet à mettre à jour après réception des données.
1062
	 *  -	'recherche' est une chaîne de caractères représentant tout ou partie du nom d'une collection.
1063
	 *  		Si la chaîne est vide, alors toutes les collections sont recherchées.
1064
	 *  -	'start' et 'nbElements' sont les paramètres indispensables à la pagination. 'start'
1065
	 *  		est le paramètre qui décrit le numéro du tuple de départ et 'nbElements' le nombre
1066
	 *  		d'éléments à collecter.
1067
	 *
1068
	 * Préconditions :
1069
	 * ---------------
1070
	 *  -	'vueARafraichir' doit être non NULL et référencer un objet implémentant l'interface
1071
	 *  		'Rafraichissable'
1072
	 *  -	'recherche' doit être non NULL.
1073
	 *  -	'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro.
1074
	 *
1075
	 *****************************************************************************************************/
1367 cyprien 1076
	public void selectionnerCollection(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur)	{
1077
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Collection");
1078
		Integer seqId = null;
1079
		if (sequenceur!=null)	{
1080
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1081
			vueARafraichir = sequenceur;
1082
		}
1083
		modele.selectionnerCollection(vueARafraichir, recherche, start, nbElements, seqId);
1428 cyprien 1084
	}
1329 cyprien 1085
 
1367 cyprien 1086
	/** AJOUTER **/
453 jp_milcent 1087
	public void ajouterCollection(Rafraichissable vueARafraichir, Collection collection) {
968 jpm 1088
		modele.ajouterCollection(vueARafraichir, collection);
453 jp_milcent 1089
	}
1090
 
1367 cyprien 1091
	/** MODIFIER **/
453 jp_milcent 1092
	public void modifierCollection(Rafraichissable vueARafraichir, Collection collection) {
872 jpm 1093
		modele.modifierCollection(vueARafraichir, collection);
453 jp_milcent 1094
	}
1095
 
1367 cyprien 1096
	/** SUPPRIMER **/
968 jpm 1097
	public void supprimerCollection(Rafraichissable vueARafraichir, List<Collection> collectionsListe) {
1098
		if (collectionsListe != null && collectionsListe.size() > 0) {
1099
			String idCollectionSeparesParVirgule = "" ;
1100
			Iterator<Collection> it = collectionsListe.iterator();
1101
			while (it.hasNext()) {
1102
				idCollectionSeparesParVirgule += it.next().getId();
1103
				if (it.hasNext()) {
1104
					idCollectionSeparesParVirgule += ",";
1105
				}
1106
			}
1107
			modele.supprimerCollection(vueARafraichir, idCollectionSeparesParVirgule);
1108
			modele.supprimerCollectionAPersonne(vueARafraichir, idCollectionSeparesParVirgule);
1109
			modele.supprimerCollectionAPublication(vueARafraichir, idCollectionSeparesParVirgule);
1110
			//modele.supprimerCollectionACommentaire(vueARafraichir, idCollectionSeparesParVirgule);
1111
		}
1112
 
453 jp_milcent 1113
	}
1114
 
447 jp_milcent 1115
	//+----------------------------------------------------------------------------------------------------------------+
875 jpm 1116
	// GESTION de la relation COLLECTION A PERSONNE
1117
 
1468 jpm 1118
	public void selectionnerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, String roleId, String recherche, int start, int nbElements, Sequenceur sequenceur)	{
1119
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  CollectionAPersonne");
1120
		Integer seqId = null;
1121
		if (sequenceur!=null)	{
1122
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1123
			vueARafraichir = sequenceur;
1124
		}
1125
		modele.selectionnerCollectionAPersonne(vueARafraichir, collectionId, roleId, recherche, start, nbElements, seqId);
1126
	}
1127
 
1367 cyprien 1128
	public void selectionnerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, String roleId, Sequenceur sequenceur) {
1129
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  CollectionAPersonne");
1130
		Integer seqId = null;
1131
		if (sequenceur!=null)	{
1132
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1133
			vueARafraichir = sequenceur;
1134
		}
1135
		modele.selectionnerCollectionAPersonne(vueARafraichir, collectionId, roleId, seqId);
875 jpm 1136
	}
1137
 
1367 cyprien 1138
	/** AJOUTER **/
875 jpm 1139
	public void ajouterCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, CollectionAPersonneListe personnesAjoutees) {
1140
		if (personnesAjoutees != null && personnesAjoutees.size() > 0) {
1141
			for (Iterator<String> it = personnesAjoutees.keySet().iterator(); it.hasNext();) {
1142
				modele.ajouterCollectionAPersonne(vueARafraichir, collectionId, (CollectionAPersonne) personnesAjoutees.get(it.next()));
1143
			}
1144
		}
1145
	}
1146
 
1367 cyprien 1147
	/** MODIFIER **/
875 jpm 1148
	public void modifierCollectionAPersonne(Rafraichissable vueARafraichir, CollectionAPersonneListe personnesModifiees) {
1149
		if (personnesModifiees != null && personnesModifiees.size() > 0) {
1150
			for (Iterator<String> it = personnesModifiees.keySet().iterator(); it.hasNext();) {
1151
				modele.modifierCollectionAPersonne(vueARafraichir, (CollectionAPersonne) personnesModifiees.get(it.next()));
1152
			}
1153
		}
1154
	}
1155
 
1367 cyprien 1156
	/** SUPPRIMER **/
875 jpm 1157
	public void supprimerCollectionAPersonne(Rafraichissable vueARafraichir, CollectionAPersonneListe personnesSupprimees) {
1158
		if (personnesSupprimees != null && personnesSupprimees.size() > 0) {
1159
			String idCollectionAPersonneSeparesParVirgule = "" ;
1160
			for (Iterator<String> it = personnesSupprimees.keySet().iterator(); it.hasNext();) {
901 jpm 1161
				idCollectionAPersonneSeparesParVirgule += personnesSupprimees.get(it.next()).getId();
1162
				if (it.hasNext()) {
1163
					idCollectionAPersonneSeparesParVirgule += ",";
1164
				}
875 jpm 1165
			}
1166
			modele.supprimerCollectionAPersonne(vueARafraichir, idCollectionAPersonneSeparesParVirgule);
1167
		}
1168
	}
1169
 
1170
	//+----------------------------------------------------------------------------------------------------------------+
1171
	// GESTION de la relation COLLECTION A PUBLICATION
1172
 
1513 jpm 1173
	public void selectionnerCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, String recherche, int start, int nbElements, Sequenceur sequenceur)	{
1174
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  CollectionAPublication");
1175
		Integer seqId = null;
1176
		if (sequenceur!=null)	{
1177
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1178
			vueARafraichir = sequenceur;
1179
		}
1180
		modele.selectionnerCollectionAPublication(vueARafraichir, collectionId, recherche, start, nbElements, seqId);
1181
	}
1182
 
1367 cyprien 1183
	public void selectionnerCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, Sequenceur sequenceur) {
1184
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  CollectionAPublication");
1185
		Integer seqId = null;
1186
		if (sequenceur!=null)	{
1187
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1188
			vueARafraichir = sequenceur;
1189
		}
1190
		modele.selectionnerCollectionAPublication(vueARafraichir, collectionId, seqId);
883 jpm 1191
	}
1192
 
1193
	public void ajouterCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, CollectionAPublicationListe publicationsAjoutees) {
1194
		if (publicationsAjoutees != null && publicationsAjoutees.size() > 0) {
1195
			for (Iterator<String> it = publicationsAjoutees.keySet().iterator(); it.hasNext();) {
1196
				modele.ajouterCollectionAPublication(vueARafraichir, collectionId, (CollectionAPublication) publicationsAjoutees.get(it.next()));
1197
			}
1198
		}
1199
	}
1200
 
1201
	public void modifierCollectionAPublication(Rafraichissable vueARafraichir, CollectionAPublicationListe publicationsModifiees) {
1202
		if (publicationsModifiees != null && publicationsModifiees.size() > 0) {
1203
			for (Iterator<String> it = publicationsModifiees.keySet().iterator(); it.hasNext();) {
1204
				modele.modifierCollectionAPublication(vueARafraichir, (CollectionAPublication) publicationsModifiees.get(it.next()));
1205
			}
1206
		}
1207
	}
1208
 
907 jpm 1209
	public void supprimerCollectionAPublication(Rafraichissable vueARafraichir, CollectionAPublicationListe publicationsSupprimees) {
883 jpm 1210
		if (publicationsSupprimees != null && publicationsSupprimees.size() > 0) {
1211
			String idCollectionAPublicationSeparesParVirgule = "" ;
1212
			for (Iterator<String> it = publicationsSupprimees.keySet().iterator(); it.hasNext();) {
901 jpm 1213
				idCollectionAPublicationSeparesParVirgule += publicationsSupprimees.get(it.next()).getId();
1214
				if (it.hasNext()) {
1215
					idCollectionAPublicationSeparesParVirgule += ",";
1216
				}
883 jpm 1217
			}
1218
			modele.supprimerCollectionAPublication(vueARafraichir, idCollectionAPublicationSeparesParVirgule);
1219
		}
1220
	}
941 jpm 1221
 
875 jpm 1222
	//+----------------------------------------------------------------------------------------------------------------+
1223
	// GESTION de la relation COLLECTION A COMMENTAIRE
1224
 
1367 cyprien 1225
	public void selectionnerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, Sequenceur sequenceur) {
1226
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  CollectionACommentaire");
1227
		Integer seqId = null;
1228
		if (sequenceur!=null)	{
1229
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1230
			vueARafraichir = sequenceur;
1231
		}
1232
		modele.selectionnerCollectionACommentaire(vueARafraichir, collectionId, seqId);
989 jpm 1233
	}
1234
 
1513 jpm 1235
	public void selectionnerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, String recherche, int pageCourante, int nbElements, Sequenceur sequenceur) {
1236
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner CollectionACommentaire");
1237
		Integer seqId = null;
1238
		if (sequenceur != null)	{
1239
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1240
			vueARafraichir = sequenceur;
1241
		}
1242
		modele.selectionnerCollectionACommentaire(vueARafraichir, collectionId, recherche, pageCourante, nbElements, seqId);
1243
	}
1244
 
1367 cyprien 1245
	/** AJOUTER **/
997 jpm 1246
	public void ajouterCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, CollectionACommentaireListe commentairesAjoutees) {
989 jpm 1247
		if (commentairesAjoutees != null && commentairesAjoutees.size() > 0) {
1248
			for (Iterator<String> it = commentairesAjoutees.keySet().iterator(); it.hasNext();) {
997 jpm 1249
				modele.ajouterCollectionACommentaire(vueARafraichir, collectionId, (CollectionACommentaire) commentairesAjoutees.get(it.next()));
989 jpm 1250
			}
1251
		}
1252
	}
1253
 
1367 cyprien 1254
	/** MODIFIER **/
989 jpm 1255
	public void modifierCollectionACommentaire(Rafraichissable vueARafraichir, CollectionACommentaireListe commentairesModifiees) {
1256
		if (commentairesModifiees != null && commentairesModifiees.size() > 0) {
1257
			for (Iterator<String> it = commentairesModifiees.keySet().iterator(); it.hasNext();) {
1258
				modele.modifierCollectionACommentaire(vueARafraichir, (CollectionACommentaire) commentairesModifiees.get(it.next()));
1259
			}
1260
		}
1261
	}
1262
 
1367 cyprien 1263
	/** SUPPRIMER **/
989 jpm 1264
	public void supprimerCollectionACommentaire(Rafraichissable vueARafraichir, CollectionACommentaireListe commentairesSupprimees) {
1265
		if (commentairesSupprimees != null && commentairesSupprimees.size() > 0) {
1266
			String idCollectionACommentaireSeparesParVirgule = "" ;
1267
			for (Iterator<String> it = commentairesSupprimees.keySet().iterator(); it.hasNext();) {
1268
				idCollectionACommentaireSeparesParVirgule += commentairesSupprimees.get(it.next()).getId();
1269
				if (it.hasNext()) {
1270
					idCollectionACommentaireSeparesParVirgule += ",";
1271
				}
1272
			}
1273
			modele.supprimerCollectionACommentaire(vueARafraichir, idCollectionACommentaireSeparesParVirgule, CollectionACommentaireAsyncDao.SUPPRESSION_PAR_COLLECTION);
1274
		}
1275
	}
875 jpm 1276
	//+----------------------------------------------------------------------------------------------------------------+
156 jp_milcent 1277
	//												GESTION DES PERSONNES
1278
	//+----------------------------------------------------------------------------------------------------------------+
1279
 
278 jp_milcent 1280
	public void afficherListePersonnes(PersonneListe personnesACharger)	{
646 jp_milcent 1281
		if (!(panneauCentre.getContenu() instanceof PersonneVue))	{
626 gduche 1282
			panneauCentre.removeAll();
646 jp_milcent 1283
			panneauCentre.add(new PersonneVue(this));
673 aurelien 1284
			panneauCentre.setId(ComposantId.PANNEAU_PERSONNE_LISTES);
626 gduche 1285
		}
599 gduche 1286
 
646 jp_milcent 1287
		panneauCentre.getContenu().rafraichir(personnesACharger);
156 jp_milcent 1288
	}
918 jpm 1289
 
1613 aurelien 1290
	public void afficherFormPersonne(String personneId)	{
1291
		final FenetreForm fenetre = new FenetreForm("");
1292
		PersonneForm personneForm = new PersonneForm(this, personneId)  {
1293
			@Override
1294
			public void surFermetureFormulaire() {
1295
				fenetre.hide();
1296
			}
1297
		};
1298
		personneForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu();
1299
		fenetre.add(personneForm);
1300
		fenetre.show();
918 jpm 1301
	}
156 jp_milcent 1302
 
918 jpm 1303
	public void clicListePersonne(Personne personne)	{
1304
		panneauCentre.getContenu().rafraichir(personne);
1305
	}
1306
 
128 gduche 1307
	public void clicAjouterPersonne()	{
918 jpm 1308
		afficherFormPersonne(null);
128 gduche 1309
	}
1310
 
918 jpm 1311
	public void clicModifierPersonne(List<Personne> selection)	{
1312
		if (selection.size() == 0) {
1210 cyprien 1313
			InfoLogger.display("Information", "Veuillez sélectionner une personne.");
918 jpm 1314
		} else if (selection.size() > 1) {
1210 cyprien 1315
			InfoLogger.display("Information", "Veuillez sélectionner une seule personne à la fois.");
918 jpm 1316
		} else if (selection.size() == 1) {
1317
			afficherFormPersonne(selection.get(0).getId());
1318
		} else {
1210 cyprien 1319
			InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierPersonne() du Médiateur.");
918 jpm 1320
		}
841 gduche 1321
	}
1322
 
285 gduche 1323
 
919 jpm 1324
	public void clicSupprimerPersonne(final Rafraichissable vue, final List<Personne> personneSelection) {
663 gduche 1325
		//Empecher suppression utilisateur
1326
		for (int i=0; i < personneSelection.size(); i++)	{
1327
			Personne courante = personneSelection.get(i);
1328
			if (courante.getId().equals(getUtilisateurId()))	{
1210 cyprien 1329
				InfoLogger.display("Information", "Vous ne pouvez pas supprimer votre compte");
663 gduche 1330
				personneSelection.remove(courante);
1331
			}
1332
		}
1333
 
245 jp_milcent 1334
		if (personneSelection.size() == 0) {
1210 cyprien 1335
			InfoLogger.display("Information", "Veuillez sélectionner une personne.");
245 jp_milcent 1336
		} else if(personneSelection.size() > 0) {
1337
			String message = "Êtes vous sur de vouloir supprimer les personnes sélectionnées ?";
1338
			if (personneSelection.size() == 1) {
1339
				message = "Êtes vous sur de vouloir supprimer la personne sélectionnée ?";
1340
			}
315 gduche 1341
 
502 gduche 1342
			final Listener<MessageBoxEvent> listenerSuppression = new Listener<MessageBoxEvent>() {
1343
				public void handleEvent(MessageBoxEvent ce) {
1344
					Dialog dialog = (Dialog) ce.getComponent();
1345
					Button btn = ce.getButtonClicked();
327 jp_milcent 1346
 
1680 raphael 1347
					if (btn.getHtml().equals(dialog.yesText)) {
772 jpm 1348
						String idPersonneSepareParVirgule = "" ;
347 gduche 1349
						Iterator<Personne> itPersonne = personneSelection.iterator();
1350
						while (itPersonne.hasNext()) {
1351
							Personne personneCourante = itPersonne.next();
772 jpm 1352
							idPersonneSepareParVirgule += personneCourante.getId();
1353
							idPersonneSepareParVirgule +=",";
327 jp_milcent 1354
						}
772 jpm 1355
						modele.supprimerPersonne(vue, idPersonneSepareParVirgule);
327 jp_milcent 1356
					}
1357
				}
1358
			};
453 jp_milcent 1359
 
315 gduche 1360
			MessageBox.confirm("Supprimer une personne", message, listenerSuppression);
245 jp_milcent 1361
		} else {
1210 cyprien 1362
			InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerPersonne() du Médiateur.");
245 jp_milcent 1363
		}
1364
	}
277 jp_milcent 1365
 
1329 cyprien 1366
	/****************************************************************************************************
1367
	/** selectionnerPersonne(Rafraichissable vueARafraichir, String recherche, int start, int nbElements)
1368
	/****************************************************************************************************
1369
	 * Action :
1370
	 * --------
1371
	 * -	Récupère un nombre défini de personnes en s'aidant du nom partiel ou complet de la personne.
1372
	 *
1373
	 * Description des paramètres :
1374
	 * ----------------------------
1375
	 *  -	'vueARafraichir' référence l'objet à mettre à jour après réception des données.
1376
	 *  -	'recherche' est une chaîne de caractères représentant tout ou partie du nom d'une personne.
1377
	 *  		Si la chaîne est vide, alors toutes les personnes sont recherchées.
1378
	 *  -	'start' et 'nbElements' sont les paramètres indispensables à la pagination. 'start'
1379
	 *  		est le paramètre qui décrit le numéro du tuple de départ et 'nbElements' le nombre
1380
	 *  		d'éléments à collecter.
1381
	 *
1382
	 * Préconditions :
1383
	 * ---------------
1384
	 *  -	'vueARafraichir' doit être non NULL et référencer un objet implémentant l'interface
1385
	 *  		'Rafraichissable'
1386
	 *  -	'recherche' doit être non NULL.
1387
	 *  -	'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro.
1388
	 *
1389
	 *****************************************************************************************************/
1367 cyprien 1390
	public void selectionnerPersonne(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) {
1391
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Personne");
1392
		Integer seqId = null;
1393
		if (sequenceur!=null)	{
1394
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1395
			vueARafraichir = sequenceur;
1396
		}
1397
		modele.selectionnerPersonne(vueARafraichir, recherche, start, nbElements, seqId);
1329 cyprien 1398
	}
1399
 
1367 cyprien 1400
	/** Cette méthode est un "wrapper" **/
1324 gduche 1401
	public void selectionnerPersonne(Rafraichissable vueARafraichir, Personne personne, String projetId, Sequenceur sequenceur)	{
1367 cyprien 1402
		selectionnerPersonne(vueARafraichir, personne, projetId, 0, nbElements, sequenceur);
775 jpm 1403
	}
1404
 
1324 gduche 1405
	public void selectionnerPersonne(Rafraichissable vueARafraichir, Personne personne, String projetId, int start, int nbElements, Sequenceur sequenceur)	{
1367 cyprien 1406
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Personne");
1324 gduche 1407
		Integer seqId = null;
1408
		if (sequenceur!=null)	{
1409
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1410
			vueARafraichir = sequenceur;
1411
		}
1412
		String personneId = null;
1413
		String personneNom = null;
1414
		if (personne != null)	{
1415
			personneId = personne.getId();
1416
			personneNom = personne.getNom();
1417
		}
1418
		modele.selectionnerPersonne(vueARafraichir, personneId, projetId, personneNom, start, nbElements, seqId);
1419
	}
1420
 
1428 cyprien 1421
	public void selectionnerPersonne(Rafraichissable vueARafraichir, String idPersonne, Sequenceur sequenceur)	{
1422
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Personne");
1423
		Integer seqId = null;
1424
		if (sequenceur!=null)	{
1425
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1426
			vueARafraichir = sequenceur;
1427
		}
1428
		modele.selectionnerPersonne(vueARafraichir, idPersonne, null, null, -1, nbElements, seqId);
1429
	}
1430
 
1367 cyprien 1431
	public void selectionnerPersonneParNomComplet(Rafraichissable vueARafraichir, String projetId, String nomComplet, Sequenceur sequenceur) {
1432
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Personne");
1433
		Integer seqId = null;
1434
		if (sequenceur!=null)	{
1435
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1436
			vueARafraichir = sequenceur;
775 jpm 1437
		}
1367 cyprien 1438
		modele.selectionnerPersonne(vueARafraichir, null, projetId, nomComplet, 0, -1, seqId);
775 jpm 1439
	}
1440
 
1367 cyprien 1441
	public void selectionnerPersonneParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) {
1442
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Personne");
1443
		Integer seqId = null;
1444
		if (sequenceur!=null)	{
1445
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1446
			vueARafraichir = sequenceur;
1447
		}
1448
		modele.selectionnerPersonne(vueARafraichir, null, projetId, null, 0, -1, seqId);
277 jp_milcent 1449
	}
245 jp_milcent 1450
 
1367 cyprien 1451
	/** ENREGISTRER **/
389 gduche 1452
	public void enregistrerPersonne(Rafraichissable vue, Personne personne){
774 jpm 1453
		if (personne.getId() != null && !personne.getId().trim().equals("")) {
429 gduche 1454
			modele.modifierPersonne(vue, personne);
1455
		}	else {
1324 gduche 1456
			modele.ajouterPersonne(vue, personne);
429 gduche 1457
		}
389 gduche 1458
	}
1459
 
156 jp_milcent 1460
	//+----------------------------------------------------------------------------------------------------------------+
1461
	//												GESTION DES PUBLICATIONS
1462
	//+----------------------------------------------------------------------------------------------------------------+
1463
 
107 aurelien 1464
	public void afficherListePublication(PublicationListe nouvelleDonnees) {
673 aurelien 1465
		if (!(panneauCentre.getContenu() instanceof PublicationVue))	{
626 gduche 1466
			panneauCentre.removeAll();
918 jpm 1467
			panneauCentre.add(new PublicationVue(this));
626 gduche 1468
		}
1469
 
646 jp_milcent 1470
		panneauCentre.getContenu().rafraichir(nouvelleDonnees);
107 aurelien 1471
	}
715 aurelien 1472
 
775 jpm 1473
	public void afficherFormPublication(String publicationId) {
1613 aurelien 1474
		final FenetreForm fenetre = new FenetreForm("");
1475
		PublicationForm publicationForm = new PublicationForm(this, publicationId) {
1476
			@Override
1477
			public void surFermetureFormulaire()  {
1478
				fenetre.hide();
1479
			}
1480
		};
1481
		publicationForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu();
1482
		fenetre.add(publicationForm);
1483
		fenetre.show();
715 aurelien 1484
	}
775 jpm 1485
 
107 aurelien 1486
	public void clicListePublication(Publication publication) {
775 jpm 1487
		if (publication != null) {
675 aurelien 1488
			panneauCentre.getContenu().rafraichir(publication);
1489
		}
107 aurelien 1490
	}
1491
 
1492
	public void clicAjouterPublication() {
775 jpm 1493
		afficherFormPublication(null);
107 aurelien 1494
	}
156 jp_milcent 1495
 
775 jpm 1496
	public void clicModifierPublication(List<Publication> selection) {
1497
		if (selection.size() == 0) {
1210 cyprien 1498
			InfoLogger.display("Information", "Veuillez sélectionner une publication.");
775 jpm 1499
		} else if (selection.size() > 1) {
1210 cyprien 1500
			InfoLogger.display("Information", "Veuillez sélectionner une seule publication à la fois.");
775 jpm 1501
		} else if (selection.size() == 1) {
1502
			afficherFormPublication(selection.get(0).getId());
379 jp_milcent 1503
		} else {
1210 cyprien 1504
			InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierPublication() du Médiateur.");
245 jp_milcent 1505
		}
1506
	}
1507
 
315 gduche 1508
	public void clicSupprimerPublication(final List<Publication> publicationListe) {
453 jp_milcent 1509
		if (publicationListe.size() <= 0) {
315 gduche 1510
			MessageBox.alert("Attention", "Vous devez sélectionner une publication", null);
379 jp_milcent 1511
		} else {
1607 aurelien 1512
			String messageComplement = "(ceci supprimera également les liens avec leurs auteurs et leurs collections)";
1606 aurelien 1513
			String message = "Voulez-vous vraiment supprimer ces publications "+messageComplement+" ?";
775 jpm 1514
			if (publicationListe.size() == 1) {
1606 aurelien 1515
				message = "Voulez-vous vraiment supprimer cette publication "+messageComplement+" ?";
245 jp_milcent 1516
			}
315 gduche 1517
 
502 gduche 1518
			final Listener<MessageBoxEvent> listenerSuppression = new Listener<MessageBoxEvent>() {
1519
				public void handleEvent(MessageBoxEvent ce) {
1520
					Dialog dialog = (Dialog) ce.getComponent();
1521
				    Button btn = ce.getButtonClicked();
315 gduche 1522
 
1680 raphael 1523
				    if (btn.getHtml().equals(dialog.yesText)) {
919 jpm 1524
				    	supprimerPublication(panneauCentre.getContenu(), publicationListe);
315 gduche 1525
				    }
1526
				}
1527
			};
1528
 
1529
			MessageBox.confirm("Supprimer une publication", message, listenerSuppression);
245 jp_milcent 1530
		}
1531
	}
709 jp_milcent 1532
 
1367 cyprien 1533
	/** Cette méthode est un "wrapper" */
1324 gduche 1534
	public void selectionnerPublication(Rafraichissable vueARafraichir, String publicationId, Sequenceur sequenceur) {
1367 cyprien 1535
		selectionnerPublication(vueARafraichir, getProjetId(), publicationId, null, 0, nbElements, sequenceur);
709 jp_milcent 1536
	}
1537
 
1367 cyprien 1538
	/** Cette méthode est un "wrapper" */
709 jp_milcent 1539
	public void selectionnerPublicationParNomComplet(Rafraichissable vueARafraichir, String projetId, String nomComplet) {
1324 gduche 1540
		selectionnerPublication(vueARafraichir, projetId, null, nomComplet, 0, nbElements, null);
709 jp_milcent 1541
	}
1542
 
1367 cyprien 1543
	public void selectionnerPublication(Rafraichissable vueARafraichir, String projetId, String publicationId, String nomComplet, int pageCourante, int nbElements, Sequenceur sequenceur) {
1544
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Publication");
1545
		Integer seqId = null;
1546
		if (sequenceur!=null)	{
1547
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1548
			vueARafraichir = sequenceur;
1549
		}
1513 jpm 1550
		modele.selectionnerPublication(vueARafraichir, publicationId, projetId, nomComplet, pageCourante, nbElements, seqId);
1046 gduche 1551
	}
1367 cyprien 1552
 
1513 jpm 1553
	public void selectionnerPublication(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) {
1554
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Publication");
1555
		Integer seqId = null;
1556
		if (sequenceur!=null)	{
1557
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1558
			vueARafraichir = sequenceur;
1559
		}
1560
		modele.selectionnerPublication(vueARafraichir, recherche, start, nbElements, seqId);
1561
	}
1562
 
1367 cyprien 1563
	/** AJOUTER **/
1324 gduche 1564
	public void ajouterPublication(Rafraichissable vueARafraichir, Publication publication, Integer seqId) {
1565
		modele.ajouterPublication(vueARafraichir, publication, seqId);
245 jp_milcent 1566
	}
1567
 
1367 cyprien 1568
	/** MODIFIER **/
1324 gduche 1569
	public void modifierPublication(Rafraichissable vueARafraichir, Publication publication, Integer seqId) {
1570
		modele.modifierPublication(vueARafraichir, publication, seqId);
245 jp_milcent 1571
	}
919 jpm 1572
 
1367 cyprien 1573
	/** SUPPRIMER **/
1324 gduche 1574
	public void supprimerPublication(Rafraichissable vueARafraichir, List<Publication> publicationsListe) {
919 jpm 1575
		if (publicationsListe != null && publicationsListe.size() > 0) {
1576
			String idPublicationSeparesParVirgule = "" ;
1577
			Iterator<Publication> it = publicationsListe.iterator();
1578
			while (it.hasNext()) {
1579
				idPublicationSeparesParVirgule += it.next().getId();
1580
				if (it.hasNext()) {
1581
					idPublicationSeparesParVirgule += ",";
1582
				}
1583
			}
1584
			modele.supprimerPublication(vueARafraichir, idPublicationSeparesParVirgule);
1585
		}
1586
	}
245 jp_milcent 1587
 
453 jp_milcent 1588
	public void clicObtenirListeEditeurs(Rafraichissable vueARafraichir) {
1367 cyprien 1589
		selectionnerStructureParProjet(vueARafraichir, null, null);
245 jp_milcent 1590
	}
1591
 
453 jp_milcent 1592
	public void clicObtenirListeAuteurs(Rafraichissable vueARafraichir) {
1367 cyprien 1593
		selectionnerPersonneParProjet(vueARafraichir, null, null);
245 jp_milcent 1594
	}
1595
 
156 jp_milcent 1596
	//+----------------------------------------------------------------------------------------------------------------+
822 jpm 1597
	// GESTION de la relation PUBLICATION A PERSONNE
1598
 
1324 gduche 1599
	public void selectionnerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, String roleId, Sequenceur sequenceur) {
1367 cyprien 1600
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  PublicationAPersonne");
1324 gduche 1601
		Integer seqId = null;
1602
		if (sequenceur != null)	{
1603
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1604
			vueARafraichir = sequenceur;
1605
		}
1606
		modele.selectionPublicationAPersonne(vueARafraichir, publicationId, personnesId, roleId, seqId);
822 jpm 1607
	}
1608
 
1367 cyprien 1609
	public void selectionnerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, List<Valeur> roleId, Sequenceur sequenceur) {
1610
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  PublicationAPersonne");
1611
		Integer seqId = null;
1612
		if (sequenceur != null)	{
1613
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1614
			vueARafraichir = sequenceur;
1615
		}
1616
 
1014 gduche 1617
		String roleIds = "";
1618
		Iterator<Valeur> itRole = roleId.iterator();
1619
		while (itRole.hasNext())	{
1620
			roleIds+= itRole.next().getId();
1621
			if (itRole.hasNext())	{
1622
				roleIds+=",";
1623
			}
1624
		}
1367 cyprien 1625
		modele.selectionPublicationAPersonne(vueARafraichir, publicationId, personnesId, roleIds, seqId);
1014 gduche 1626
	}
1513 jpm 1627
 
1628
	public void selectionnerPublicationsAPersonne(Rafraichissable vueARafraichir, String personneId, List<Valeur> roleId, String recherche, int pageCourante, int nbElements, Sequenceur sequenceur) {
1629
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner PublicationAPersonne");
1630
		Integer seqId = null;
1631
		if (sequenceur != null)	{
1632
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1633
			vueARafraichir = sequenceur;
1634
		}
1635
 
1636
		String roleIds = "";
1637
		Iterator<Valeur> itRole = roleId.iterator();
1638
		while (itRole.hasNext())	{
1639
			roleIds+= itRole.next().getId();
1640
			if (itRole.hasNext())	{
1641
				roleIds+=",";
1642
			}
1643
		}
1644
		modele.selectionPublicationsAPersonne(vueARafraichir, personneId, roleIds, recherche, pageCourante, nbElements, seqId);
1645
	}
1646
 
1647
	public void selectionnerPersonnesAPublication(Rafraichissable vueARafraichir, String publicationId, String recherche, int pageCourante, int nbElements, Sequenceur sequenceur) {
1648
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner PublicationAPersonne");
1649
		Integer seqId = null;
1650
		if (sequenceur != null)	{
1651
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1652
			vueARafraichir = sequenceur;
1653
		}
1654
		modele.selectionPersonnesAPublication(vueARafraichir, publicationId, recherche, pageCourante, nbElements, seqId);
1655
	}
1428 cyprien 1656
 
1367 cyprien 1657
	/** AJOUTER **/
1428 cyprien 1658
	// Lier une publication à plusieurs personnes
1324 gduche 1659
	public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, PublicationAPersonneListe personnesAjoutees, String roleId, Integer seqId) {
901 jpm 1660
		if (personnesAjoutees != null && personnesAjoutees.size() > 0) {
1661
			String idPublicationAPersonneSepareParVirgule = "" ;
1428 cyprien 1662
			String ordreAuteursSepareParVirgule = "";
901 jpm 1663
			for (Iterator<String> it = personnesAjoutees.keySet().iterator(); it.hasNext();) {
1428 cyprien 1664
				PublicationAPersonne publi = personnesAjoutees.get(it.next());
1665
				idPublicationAPersonneSepareParVirgule += publi.getIdPersonne();
1666
				ordreAuteursSepareParVirgule += publi.getOrdreAuteurs();
901 jpm 1667
				if (it.hasNext()) {
1668
					idPublicationAPersonneSepareParVirgule += ",";
1428 cyprien 1669
					ordreAuteursSepareParVirgule += ",";
901 jpm 1670
				}
1671
			}
1428 cyprien 1672
			modele.ajouterPublicationAPersonne(vueARafraichir, publicationId, idPublicationAPersonneSepareParVirgule, ordreAuteursSepareParVirgule, roleId, seqId);
1324 gduche 1673
		}
822 jpm 1674
	}
901 jpm 1675
 
1428 cyprien 1676
	// Lier plusieurs publication à une personne
1677
	public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, PublicationAPersonneListe listePublications, String personneId, String roleId, Integer seqId) {
1468 jpm 1678
		if (listePublications != null && listePublications.size() > 0)	{
1428 cyprien 1679
			String idsPubli = "";
1680
			String rolesIds = "";
1681
			String ordreAuteurs = "";
1682
			for (Iterator<String> it = listePublications.keySet().iterator(); it.hasNext();) {
1683
				PublicationAPersonne publiAPersonne = listePublications.get(it.next());
1468 jpm 1684
				idsPubli += publiAPersonne.getIdPublication();
1428 cyprien 1685
				rolesIds += publiAPersonne.getRole();
1686
				ordreAuteurs += publiAPersonne.getOrdreAuteurs();
1687
				if (it.hasNext()) {
1688
					idsPubli += ",";
1689
					rolesIds += ",";
1690
					ordreAuteurs += ",";
1691
				}
1692
			}
1693
			modele.ajouterPublicationAPersonne(vueARafraichir, idsPubli, personneId, ordreAuteurs, rolesIds, seqId);
1694
		}
1695
	}
1696
 
1697
	/** MODIFIER **/
1698
	public void modifierPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, PublicationAPersonneListe personnesModifiees, String roleId, Integer seqId) {
1699
		if (personnesModifiees != null && personnesModifiees.size() > 0) {
1700
			String idPublicationAPersonneSepareParVirgule = "" ;
1701
			String ordreAuteursSepareParVirgule = "";
1702
			for (Iterator<String> it = personnesModifiees.keySet().iterator(); it.hasNext();) {
1703
				PublicationAPersonne publi = personnesModifiees.get(it.next());
1704
				idPublicationAPersonneSepareParVirgule += publi.getIdPersonne();
1705
				ordreAuteursSepareParVirgule += publi.getOrdreAuteurs();
1706
				if (it.hasNext()) {
1707
					idPublicationAPersonneSepareParVirgule += ",";
1708
					ordreAuteursSepareParVirgule += ",";
1709
				}
1710
			}
1711
			modele.modifierPublicationAPersonne(vueARafraichir, publicationId, idPublicationAPersonneSepareParVirgule, ordreAuteursSepareParVirgule, roleId, seqId);
1712
		}
1713
	}
1367 cyprien 1714
 
1715
	/** SUPPRIMER **/
1324 gduche 1716
	public void supprimerPublicationAPersonne(Rafraichissable vueARafraichir, PublicationAPersonneListe personnesSupprimees) {
901 jpm 1717
		if (personnesSupprimees != null && personnesSupprimees.size() > 0) {
1718
			String idPublicationAPersonneSepareParVirgule = "" ;
1719
			for (Iterator<String> it = personnesSupprimees.keySet().iterator(); it.hasNext();) {
1720
				idPublicationAPersonneSepareParVirgule += personnesSupprimees.get(it.next()).getId();
1721
				if (it.hasNext()) {
1722
					idPublicationAPersonneSepareParVirgule += ",";
1723
				}
1724
			}
1428 cyprien 1725
 
968 jpm 1726
			modele.supprimerPublicationAPersonne(vueARafraichir, idPublicationAPersonneSepareParVirgule);
1324 gduche 1727
		}
822 jpm 1728
	}
1729
 
1730
	//+----------------------------------------------------------------------------------------------------------------+
985 jpm 1731
	//												GESTION DES COMMENTAIRES
1732
	//+----------------------------------------------------------------------------------------------------------------+
1733
 
1734
	public void afficherListeCommentaire(CommentaireListe nouvelleDonnees) {
1735
		if (!(panneauCentre.getContenu() instanceof CommentaireVue)) {
1736
			panneauCentre.removeAll();
1737
			panneauCentre.add(new CommentaireVue(this));
1738
		}
1739
 
1740
		panneauCentre.getContenu().rafraichir(nouvelleDonnees);
1741
	}
1742
 
1743
	public void afficherFormCommentaire(String commentaireId) {
1613 aurelien 1744
		final FenetreForm fenetre = new FenetreForm("");
1745
		CommentaireForm commentaireForm = new CommentaireForm(this, commentaireId)  {
1746
			@Override
1747
			public void surFermetureFormulaire() {
1748
				fenetre.hide();
1749
			}
1750
		};
1751
		commentaireForm.vueExterneARafraichirApresValidation = panneauCentre.getContenu();
1752
		fenetre.add(commentaireForm);
1753
		fenetre.show();
985 jpm 1754
	}
1755
 
1756
	public void clicListeCommentaire(Commentaire commentaire) {
1757
		if (commentaire != null) {
1758
			panneauCentre.getContenu().rafraichir(commentaire);
1759
		}
1760
	}
1761
 
1762
	public void clicAjouterCommentaire() {
1763
		afficherFormCommentaire(null);
1764
	}
1765
 
1766
	public void clicModifierCommentaire(List<Commentaire> selection) {
1767
		if (selection.size() == 0) {
1210 cyprien 1768
			InfoLogger.display("Information", "Veuillez sélectionner un commentaire.");
985 jpm 1769
		} else if (selection.size() > 1) {
1210 cyprien 1770
			InfoLogger.display("Information", "Veuillez sélectionner un seul commentaire à la fois.");
985 jpm 1771
		} else if (selection.size() == 1) {
1772
			afficherFormCommentaire(selection.get(0).getId());
1773
		} else {
1210 cyprien 1774
			InfoLogger.display("Erreur", "Une erreur est survenue dans la méthode clicModifierCommentaire() du Médiateur.");
985 jpm 1775
		}
1776
	}
1777
 
1778
	public void clicSupprimerCommentaire(final List<Commentaire> commentaireListe) {
1779
		if (commentaireListe.size() <= 0) {
1780
			MessageBox.alert("Attention", "Vous devez sélectionner un commentaire", null);
1781
		} else {
1782
			String message = "Voulez-vous vraiment supprimer ces commentaires ?";
1783
			if (commentaireListe.size() == 1) {
1784
				message = "Voulez-vous vraiment supprimer ce commentaire ?";
1785
			}
1786
 
1787
			final Listener<MessageBoxEvent> listenerSuppression = new Listener<MessageBoxEvent>() {
1788
				public void handleEvent(MessageBoxEvent ce) {
1789
					Dialog dialog = (Dialog) ce.getComponent();
1790
				    Button btn = ce.getButtonClicked();
1791
 
1680 raphael 1792
				    if (btn.getHtml().equals(dialog.yesText)) {
985 jpm 1793
				    	supprimerCommentaire(panneauCentre.getContenu(), commentaireListe);
1794
				    }
1795
				}
1796
			};
1797
 
1798
			MessageBox.confirm("Supprimer un commentaire", message, listenerSuppression);
1799
		}
1800
	}
1801
 
1367 cyprien 1802
	/** Cette méthode est un wrapper **/
1803
	public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, Sequenceur sequenceur) {
1804
		selectionnerCommentaire(vueARafraichir, commentaireId, null, 0, nbElements, sequenceur);
985 jpm 1805
	}
1367 cyprien 1806
 
1807
	public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, String titre, int pageCourante, int nbElements, Sequenceur sequenceur) {
1808
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Commentaire");
1809
		Integer seqId = null;
1810
		if (sequenceur != null)	{
1811
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1812
			vueARafraichir = sequenceur;
1813
		}
1814
		modele.selectionnerCommentaire(vueARafraichir, commentaireId, getProjetId(), titre, pageCourante, nbElements, seqId);
1048 gduche 1815
	}
985 jpm 1816
 
1513 jpm 1817
	public void selectionnerCommentaire(Rafraichissable vueARafraichir, String recherche, int pageCourante, int nbElements, Sequenceur sequenceur) {
1818
		if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner  Commentaire");
1819
		Integer seqId = null;
1820
		if (sequenceur != null)	{
1821
			seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1822
			vueARafraichir = sequenceur;
1823
		}
1824
		modele.selectionnerCommentaire(vueARafraichir, recherche, pageCourante, nbElements, seqId);
1825
	}
1826
 
1367 cyprien 1827
	/** Cette méthode est un wrapper **/
1828
	public void selectionnerCommentaireParTitre(Rafraichissable vueARafraichir, String titre, Sequenceur sequenceur) {
1829
		selectionnerCommentaire(vueARafraichir, null, titre, 0, nbElements, sequenceur);
997 jpm 1830
	}
1831
 
1367 cyprien 1832
	/** AJOUTER **/
985 jpm 1833
	public void ajouterCommentaire(Rafraichissable vueARafraichir, Commentaire commentaire) {
1834
		modele.ajouterCommentaire(vueARafraichir, commentaire);
1835
	}
1836
 
1367 cyprien 1837
	/** MODIFIER **/
985 jpm 1838
	public void modifierCommentaire(Rafraichissable vueARafraichir, Commentaire commentaire) {
1839
		modele.modifierCommentaire(vueARafraichir, commentaire);
1840
	}
1841
 
1367 cyprien 1842
	/** SUPPRIMER **/
985 jpm 1843
	public void supprimerCommentaire(Rafraichissable vueARafraichir, List<Commentaire> commentairesListe) {
1844
		if (commentairesListe != null && commentairesListe.size() > 0) {
1845
			String idCommentaireSeparesParVirgule = "" ;
1846
			Iterator<Commentaire> it = commentairesListe.iterator();
1847
			while (it.hasNext()) {
1848
				idCommentaireSeparesParVirgule += it.next().getId();
1849
				if (it.hasNext()) {
1850
					idCommentaireSeparesParVirgule += ",";
1851
				}
1852
			}
1853
			modele.supprimerCommentaire(vueARafraichir, idCommentaireSeparesParVirgule);
989 jpm 1854
			modele.supprimerCollectionACommentaire(vueARafraichir, idCommentaireSeparesParVirgule, CollectionACommentaireAsyncDao.SUPPRESSION_PAR_COMMENTAIRE);
985 jpm 1855
		}
1856
	}
1857
 
1858
	//+----------------------------------------------------------------------------------------------------------------+
447 jp_milcent 1859
	//												RAFRAICHISSEMENT
156 jp_milcent 1860
	//+----------------------------------------------------------------------------------------------------------------+
1861
 
898 gduche 1862
	public void rafraichir(Object nouvellesDonnees) {
1863
		if (nouvellesDonnees instanceof Utilisateur) {
932 jpm 1864
			repandreEtatIdentification((Utilisateur) nouvellesDonnees);
1865
		} else if (nouvellesDonnees instanceof Information) {
1866
			Information info = (Information) nouvellesDonnees;
1867
			if (info.getType().equals("modification_personne")) {
1868
				repandreInfoMiseAJourUtilisateur();
1869
			}
1870
		} else {
898 gduche 1871
			GWT.log(i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
277 jp_milcent 1872
		}
1873
	}
281 gduche 1874
 
453 jp_milcent 1875
	//+----------------------------------------------------------------------------------------------------------------+
1876
	//												GESTION du STATUT
1877
	//+----------------------------------------------------------------------------------------------------------------+
288 gduche 1878
 
332 gduche 1879
	public void afficherPopinChargement()	{
1880
		((PopupChargement) Registry.get(RegistreId.POPUP_CHARGEMENT)).center();
1881
	}
453 jp_milcent 1882
 
332 gduche 1883
	public void masquerPopinChargement()	{
1884
		((PopupChargement) Registry.get(RegistreId.POPUP_CHARGEMENT)).hide();
1885
	}
1063 gduche 1886
 
1887
	public String obtenirClasseContenu()	{
1888
		String classeContenu = null;
1889
		if (panneauCentre.getContenu() != null)	{
1890
			classeContenu = panneauCentre.getContenu().getClass().toString();
1891
		}
1892
		return classeContenu;
1509 jpm 1893
	}
1894
 
1895
	//+----------------------------------------------------------------------------------------------------------------+
1896
	//												GESTION de l'HISTORIQUE du navigateur
1897
	//+----------------------------------------------------------------------------------------------------------------+
1898
	@Override
1899
	public void onValueChange(ValueChangeEvent<String> event) {
1900
		String token = event.getValue();
1633 aurelien 1901
		if(premierChargement) {
1902
			if (token != null) {
1903
				if (token.lastIndexOf("?") == -1) {
1904
					this.requeteUrl = null;
1905
					this.clicMenu(token);
1906
				} else {
1907
					int indexDebutRequete = (token.lastIndexOf("?") + 1);
1908
					int indexFinPlace = token.lastIndexOf("?");
1909
					String place = token.substring(0, indexFinPlace);
1910
					requeteUrl = token.substring(indexDebutRequete);
1911
					Log.trace("URL Place : "+place);
1912
					Log.trace("URL Requete : "+requeteUrl);
1913
					analyseRequeteURL();
1914
					this.clicMenu(place);
1915
				}
1916
		    }
1917
		}
1918
		premierChargement = false;
1562 jpm 1919
	}
1920
 
1921
	private void analyseRequeteURL() {
1922
		String[] params = requeteUrl.split("&");
1923
		for (int i = 0; i < params.length; i++) {
1924
			if (params[i].startsWith("logLevel=")) {
1925
				String logLevel =  params[i].replaceFirst("^logLevel=", "");
1926
				Log.setNiveau(logLevel);
1927
			}
1928
		}
1929
	}
447 jp_milcent 1930
 
1654 raphael 1931
}