Subversion Repositories eFlore/Applications.coel

Rev

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

Rev Author Line No. Line
935 jpm 1
package org.tela_botanica.client.vues.publication;
219 aurelien 2
 
227 aurelien 3
import java.util.ArrayList;
4
import java.util.Iterator;
365 jp_milcent 5
import java.util.List;
227 aurelien 6
 
981 jpm 7
import org.tela_botanica.client.ComposantClass;
219 aurelien 8
import org.tela_botanica.client.Mediateur;
1329 cyprien 9
import org.tela_botanica.client.composants.ChampComboBoxRechercheTempsReelPaginable;
1284 gduche 10
import org.tela_botanica.client.composants.InfoLogger;
1369 cyprien 11
import org.tela_botanica.client.composants.pagination.ProxyPersonnes;
1329 cyprien 12
import org.tela_botanica.client.composants.pagination.ProxyProjets;
13
import org.tela_botanica.client.composants.pagination.ProxyStructures;
822 jpm 14
import org.tela_botanica.client.images.Images;
219 aurelien 15
import org.tela_botanica.client.interfaces.Rafraichissable;
705 aurelien 16
import org.tela_botanica.client.modeles.Information;
775 jpm 17
import org.tela_botanica.client.modeles.MenuApplicationId;
1284 gduche 18
import org.tela_botanica.client.modeles.aDonnee;
935 jpm 19
import org.tela_botanica.client.modeles.personne.Personne;
20
import org.tela_botanica.client.modeles.personne.PersonneListe;
1032 jpm 21
import org.tela_botanica.client.modeles.projet.Projet;
935 jpm 22
import org.tela_botanica.client.modeles.publication.Publication;
23
import org.tela_botanica.client.modeles.publication.PublicationAPersonne;
24
import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe;
25
import org.tela_botanica.client.modeles.structure.Structure;
1322 gduche 26
import org.tela_botanica.client.synchronisation.Sequenceur;
1329 cyprien 27
import org.tela_botanica.client.util.Debug;
792 jpm 28
import org.tela_botanica.client.util.Pattern;
782 jpm 29
import org.tela_botanica.client.util.UtilArray;
884 jpm 30
import org.tela_botanica.client.util.UtilString;
1284 gduche 31
import org.tela_botanica.client.vues.FenetreForm;
935 jpm 32
import org.tela_botanica.client.vues.Formulaire;
1284 gduche 33
import org.tela_botanica.client.vues.FormulaireBarreValidation;
34
import org.tela_botanica.client.vues.personne.PersonneForm;
219 aurelien 35
 
1284 gduche 36
import com.extjs.gxt.ui.client.Style.Scroll;
37
import com.extjs.gxt.ui.client.Style.SortDir;
1329 cyprien 38
import com.extjs.gxt.ui.client.data.ModelData;
39
import com.extjs.gxt.ui.client.data.ModelType;
1284 gduche 40
import com.extjs.gxt.ui.client.event.BaseEvent;
505 jp_milcent 41
import com.extjs.gxt.ui.client.event.ButtonEvent;
980 jpm 42
import com.extjs.gxt.ui.client.event.Events;
1284 gduche 43
import com.extjs.gxt.ui.client.event.Listener;
1428 cyprien 44
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
45
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
219 aurelien 46
import com.extjs.gxt.ui.client.event.SelectionListener;
47
import com.extjs.gxt.ui.client.store.ListStore;
1284 gduche 48
import com.extjs.gxt.ui.client.store.Store;
49
import com.extjs.gxt.ui.client.store.StoreEvent;
1329 cyprien 50
import com.extjs.gxt.ui.client.widget.ContentPanel;
1095 jpm 51
import com.extjs.gxt.ui.client.widget.Info;
219 aurelien 52
import com.extjs.gxt.ui.client.widget.LayoutContainer;
705 aurelien 53
import com.extjs.gxt.ui.client.widget.MessageBox;
1284 gduche 54
import com.extjs.gxt.ui.client.widget.Text;
219 aurelien 55
import com.extjs.gxt.ui.client.widget.button.Button;
1284 gduche 56
import com.extjs.gxt.ui.client.widget.button.ButtonBar;
219 aurelien 57
import com.extjs.gxt.ui.client.widget.form.ComboBox;
1032 jpm 58
import com.extjs.gxt.ui.client.widget.form.Field;
219 aurelien 59
import com.extjs.gxt.ui.client.widget.form.FieldSet;
1284 gduche 60
import com.extjs.gxt.ui.client.widget.form.FormPanel;
219 aurelien 61
import com.extjs.gxt.ui.client.widget.form.TextField;
1032 jpm 62
import com.extjs.gxt.ui.client.widget.form.Validator;
219 aurelien 63
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
1329 cyprien 64
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
1284 gduche 65
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
66
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
67
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
68
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
1329 cyprien 69
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
1284 gduche 70
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
219 aurelien 71
import com.extjs.gxt.ui.client.widget.layout.FlowLayout;
72
import com.extjs.gxt.ui.client.widget.layout.FormData;
73
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
1284 gduche 74
import com.extjs.gxt.ui.client.widget.layout.RowData;
75
import com.extjs.gxt.ui.client.widget.layout.RowLayout;
76
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
77
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
705 aurelien 78
import com.google.gwt.core.client.GWT;
219 aurelien 79
 
877 aurelien 80
 
775 jpm 81
public class PublicationForm extends Formulaire implements Rafraichissable {
219 aurelien 82
 
1428 cyprien 83
	  //-------------//
84
	 //  ATTRIBUTS	//
85
	//-------------//
86
 
87
	/** Publication **/
88
	// on se sert d'un objet Publication lorsque l'on est en mode MODIFIER
786 jpm 89
	private Publication publication;
1428 cyprien 90
	// on se sert de l'identifiant d'une publication lorsque l'on est en mode AJOUTER
91
	private String publicationId = null;
1322 gduche 92
 
1428 cyprien 93
	/** Auteurs **/
94
	private PublicationAPersonneListe auteursInitialListe = null;
95
	private PublicationAPersonneListe auteursAjoutes = null;
96
	private PublicationAPersonneListe auteursSupprimes = null;
97
	private PublicationAPersonneListe auteursModifies = null;
219 aurelien 98
 
1329 cyprien 99
	private ContentPanel auteursFieldset = null;
100
	private ChampComboBoxRechercheTempsReelPaginable projetsCombo = null;
227 aurelien 101
 
775 jpm 102
	private FieldSet generalitesFieldset = null;
786 jpm 103
	private TextField<String> titreChp = null;
104
	private TextField<String> collectionChp = null;
105
	private TextField<String> uriChp = null;
219 aurelien 106
 
775 jpm 107
	private FieldSet editionFieldset = null;
1329 cyprien 108
	private ChampComboBoxRechercheTempsReelPaginable editeurCombobox = null;
786 jpm 109
	private TextField<String> datePublicationChp = null;
110
	private TextField<String> tomeChp = null;
111
	private TextField<String> fasciculeChp = null;
112
	private TextField<String> pagesChp = null;
219 aurelien 113
 
1284 gduche 114
	private LayoutContainer zoneHaut, zoneBas;
115
 
116
	private ToolBar barreOutils = null;
1428 cyprien 117
	private EditorGrid<PublicationAPersonne> grilleAuteurs;
1375 cyprien 118
	private ChampComboBoxRechercheTempsReelPaginable personnesSaisiesComboBox = null;
1284 gduche 119
	private Button personnesBoutonSupprimer = null;
120
	private Button personnesBoutonModifier = null;
1428 cyprien 121
	private Button boutonAuteurUp = null;
122
	private Button boutonAuteurDown = null;
1284 gduche 123
 
124
	private FenetreForm fenetreFormulaire = null;
1322 gduche 125
	private Sequenceur sequenceur;
1284 gduche 126
 
1428 cyprien 127
	private String modeDeCreation = null;
128
	boolean changeOrderMarker = false;
129
 
130
 
131
	 //----------------------//
132
	//    Constructeurs     //------------------------------------------------------------
133
 
781 jpm 134
	public PublicationForm(Mediateur mediateurCourrant, String publicationId) {
782 jpm 135
		initialiserPublicationForm(mediateurCourrant, publicationId);
136
	}
137
 
138
	public PublicationForm(Mediateur mediateurCourrant, String publicationId, Rafraichissable vueARafraichirApresValidation) {
822 jpm 139
		vueExterneARafraichirApresValidation = vueARafraichirApresValidation;
782 jpm 140
		initialiserPublicationForm(mediateurCourrant, publicationId);
141
	}
1428 cyprien 142
 
782 jpm 143
 
1428 cyprien 144
	 //-----------------------//
145
	//    Initialisation     //------------------------------------------------------------
146
 
782 jpm 147
	private void initialiserPublicationForm(Mediateur mediateurCourrant, String publicationId) {
1322 gduche 148
		sequenceur = new Sequenceur();
799 jpm 149
		publication = new Publication();
822 jpm 150
		publication.setId(publicationId);
1428 cyprien 151
		this.publicationId = publicationId;
152
		auteursInitialListe = new PublicationAPersonneListe();
1322 gduche 153
		initialiserAuteurs();	// Crée les listes d'auteurs ajoutés et supprimés
822 jpm 154
 
1428 cyprien 155
		// Si 'publicationId' est vide alors on est en mode "AJOUTER", sinon on est en mode "MODIFIER"
156
		modeDeCreation = (UtilString.isEmpty(publicationId) ? Formulaire.MODE_AJOUTER : Formulaire.MODE_MODIFIER);
775 jpm 157
		initialiserFormulaire(mediateurCourrant, modeDeCreation, MenuApplicationId.PUBLICATION);
1284 gduche 158
		panneauFormulaire.setLayout(new RowLayout());
159
		panneauFormulaire.setStyleAttribute("padding", "0");
1322 gduche 160
 
1284 gduche 161
		zoneHaut = new LayoutContainer(new FitLayout());
162
		zoneBas = new LayoutContainer(new FlowLayout());
163
		panneauFormulaire.add(zoneHaut, new RowData(1, 0.3));
164
		panneauFormulaire.add(zoneBas, new RowData(1, 0.5));
165
		panneauFormulaire.setScrollMode(Scroll.AUTO);
1095 jpm 166
		genererTitreFormulaire();
167
 
775 jpm 168
		creerZoneAuteurs();
1284 gduche 169
		zoneHaut.add(auteursFieldset);
219 aurelien 170
 
775 jpm 171
		creerZoneGeneralites();
1284 gduche 172
		zoneBas.add(generalitesFieldset);
239 aurelien 173
 
775 jpm 174
		creerZoneEdition();
1284 gduche 175
		zoneBas.add(editionFieldset);
822 jpm 176
 
177
		if (modeDeCreation.equals(Formulaire.MODE_MODIFIER)) {
1322 gduche 178
			mediateurCourrant.selectionnerPublication(this, publicationId, sequenceur);
179
			mediateurCourrant.selectionnerPublicationAPersonne(this, publicationId, null, PublicationAPersonne.ROLE_AUTEUR, sequenceur);
1373 cyprien 180
			sequenceur.enfilerRafraichissement(this, new Information("chargement_modifier_ok"));
822 jpm 181
		}
781 jpm 182
	}
1428 cyprien 183
 
184
	private void initialiserAuteurs() {
185
		auteursAjoutes = new PublicationAPersonneListe();
186
		auteursSupprimes = new PublicationAPersonneListe();
187
		auteursModifies = new PublicationAPersonneListe();
188
	}
782 jpm 189
 
1428 cyprien 190
	 //-----------------------//
191
	//    User Interface     //------------------------------------------------------------
1284 gduche 192
 
193
	private ToolBar creerBarreOutilsGrille() {
194
		ToolBar barreOutils = new ToolBar();
195
 
196
		Button ajouterBouton = creerBoutonAjouter();
197
		barreOutils.add(ajouterBouton);
198
 
199
		barreOutils.add(new Text(" ou "));
200
 
1375 cyprien 201
		creerComboBoxPersonnesSaisies();
1284 gduche 202
		barreOutils.add(personnesSaisiesComboBox);
203
 
204
		barreOutils.add(new SeparatorToolItem());
205
 
206
		personnesBoutonModifier = creerBoutonModifier();
207
		barreOutils.add(personnesBoutonModifier);
208
 
209
		barreOutils.add(new SeparatorToolItem());
210
 
211
		personnesBoutonSupprimer = creerBoutonSupprimer();
212
		barreOutils.add(personnesBoutonSupprimer);
213
 
214
		barreOutils.add(new SeparatorToolItem());
215
 
216
		Button rafraichirBouton = creerBoutonRafraichir();
217
		barreOutils.add(rafraichirBouton);
218
 
1428 cyprien 219
		barreOutils.add(new SeparatorToolItem());
220
 
221
		barreOutils.add(new Text(i18nC.deplacerAuteur()));
222
		boutonAuteurUp = creerBoutonAuteurUp();
223
		barreOutils.add(boutonAuteurUp);
224
		boutonAuteurDown = creerBoutonAuteurDown();
225
		barreOutils.add(boutonAuteurDown);
226
 
1284 gduche 227
		return barreOutils;
228
	}
1428 cyprien 229
 
230
	public void actualiserEtatBoutonsBarreOutils() {
231
		// Activation des boutons si la grille contient un élément
232
		if (grilleAuteurs.getStore().getCount() > 0) {
233
			personnesBoutonSupprimer.enable();
234
			personnesBoutonModifier.enable();
235
		}
236
		// Désactivation des boutons si la grille ne contient plus d'élément
237
		if (grilleAuteurs.getStore().getCount() == 0) {
238
			personnesBoutonSupprimer.disable();
239
			personnesBoutonModifier.disable();
240
		}
241
	}
242
 
243
	private Button creerBoutonAuteurUp() {
244
		Button bouton = new Button();
245
		bouton.setIcon(Images.ICONES.arrowUp());
246
		bouton.setEnabled(false);
247
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
248
			public void componentSelected(ButtonEvent ce) {
249
				if (grilleAuteurs.getSelectionModel().getSelectedItem() != null) {
250
 
251
					PublicationAPersonne pap = grilleAuteurs.getSelectionModel().getSelectedItem();
252
 
253
					int index = grilleAuteurs.getStore().indexOf(pap);
254
					int newIndex = index;
255
					newIndex--;
256
 
257
					// le marqueur suivant est obligatoire sinon les évènements liés au magasin se
258
					// déclenchent et posent problème
259
					changeOrderMarker = true;
260
					pap.setOrdreAuteurs(String.valueOf(newIndex+1));
261
					PublicationAPersonne papSwitch = grilleAuteurs.getStore().getAt(index-1);
262
					int newIndexPapSwitch = index + 1;
263
					papSwitch.setOrdreAuteurs(String.valueOf(newIndexPapSwitch));
264
					grilleAuteurs.getStore().update(papSwitch);
265
					grilleAuteurs.getStore().remove(pap);
266
					grilleAuteurs.getStore().insert(pap, newIndex);
267
					changeOrderMarker = false;
268
 
269
					grilleAuteurs.getSelectionModel().select(newIndex, true);
270
				}
271
			}
272
		});
273
		return bouton;
274
	}
275
 
276
	private Button creerBoutonAuteurDown() {
277
		Button bouton = new Button();
278
		bouton.setIcon(Images.ICONES.arrowDown());
279
		bouton.setEnabled(false);
280
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
281
			public void componentSelected(ButtonEvent ce) {
282
				if (grilleAuteurs.getSelectionModel().getSelectedItem() != null) {
283
 
284
					PublicationAPersonne pap = grilleAuteurs.getSelectionModel().getSelectedItem();
285
 
286
					int index = grilleAuteurs.getStore().indexOf(pap);
287
					int newIndex = index;
288
					newIndex++;
289
 
290
					// le marqueur suivant est obligatoire sinon les évènements liés au magasin se
291
					// déclenchent et posent problème
292
					changeOrderMarker = true;
293
					pap.setOrdreAuteurs(String.valueOf(newIndex+1));
294
					PublicationAPersonne papSwitch = grilleAuteurs.getStore().getAt(index+1);
295
					int newIndexPapSwitch = index + 1;
296
					papSwitch.setOrdreAuteurs(String.valueOf(newIndexPapSwitch));
297
					grilleAuteurs.getStore().update(papSwitch);
298
					grilleAuteurs.getStore().remove(pap);
299
					grilleAuteurs.getStore().insert(pap, newIndex);
300
					changeOrderMarker = false;
301
 
302
					grilleAuteurs.getSelectionModel().select(newIndex, true);
303
				}
304
			}
305
		});
306
		return bouton;
307
	}
1284 gduche 308
 
309
	private Button creerBoutonAjouter() {
310
		Button bouton = new Button(i18nC.ajouter());
311
		bouton.setIcon(Images.ICONES.vcardAjouter());
312
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
313
			public void componentSelected(ButtonEvent ce) {
314
				fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_AJOUTER);
315
				fenetreFormulaire.show();
316
			}
317
		});
318
		return bouton;
319
	}
320
 
321
	private Button creerBoutonModifier() {
322
		Button bouton = new Button(i18nC.modifier());
323
		bouton.setIcon(Images.ICONES.vcardModifier());
324
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
325
			public void componentSelected(ButtonEvent ce) {
1428 cyprien 326
				Personne personneSaisieSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem().getPersonne();
1284 gduche 327
 
328
				if (personneSaisieSelectionnee == null) {
329
					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
330
				} else {
331
					fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_MODIFIER);
332
					fenetreFormulaire.show();
333
				}
334
			}
335
		});
336
		return bouton;
337
	}
338
 
339
	private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
340
		String personneId = null;
341
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
1428 cyprien 342
			Personne personneSaisieSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem().getPersonne();
1284 gduche 343
			personneId = personneSaisieSelectionnee.getId();
344
		}
345
 
346
		final FenetreForm fenetre = new FenetreForm("");
347
		final PersonneForm formulaire = creerFormulairePersonne(fenetre, personneId);
348
		fenetre.add(formulaire);
349
		return fenetre;
350
	}
351
 
352
	private PersonneForm creerFormulairePersonne(final FenetreForm fenetre, final String personneId) {
353
		PersonneForm formulairePersonne = new PersonneForm(mediateur, personneId, this);
354
		FormPanel panneauFormulaire = formulairePersonne.getFormulaire();
355
		fenetre.setHeading(panneauFormulaire.getHeading());
356
		panneauFormulaire.setHeaderVisible(false);
357
		panneauFormulaire.setTopComponent(null);
358
 
359
		// FIXME : avec GXT-2.1.0 la redéfinition du bottom component ne marche plus. Nous le cachons et en créeons un dans la fenêtre.
360
		panneauFormulaire.getBottomComponent().hide();
361
		SelectionListener<ButtonEvent> ecouteur = creerEcouteurValidationFormulairePersonne(fenetre, formulairePersonne);
362
		final ButtonBar barreValidation = new FormulaireBarreValidation(ecouteur);
363
		fenetre.setBottomComponent(barreValidation);
364
 
365
		return formulairePersonne;
366
	}
367
 
368
	private SelectionListener<ButtonEvent> creerEcouteurValidationFormulairePersonne(final FenetreForm fenetre, final PersonneForm formulaire) {
369
		SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
370
			public void componentSelected(ButtonEvent ce) {
371
				String code = ((Button) ce.getComponent()).getData("code");
372
				if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
373
					if (formulaire.soumettreFormulaire()) {
374
						fenetre.hide();
375
					}
376
				} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
377
					formulaire.soumettreFormulaire();
378
				} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
379
					fenetre.hide();
380
				} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
381
					fenetreFormulaire.hide();
382
					fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(formulaire.mode);
383
					fenetreFormulaire.show();
384
				}
385
			}
386
		};
387
 
388
		return ecouteur;
389
	}
390
 
391
	private Button creerBoutonSupprimer() {
392
		Button bouton = new Button(i18nC.supprimer());
393
		bouton.setIcon(Images.ICONES.vcardSupprimer());
394
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
395
			public void componentSelected(ButtonEvent ce) {
1428 cyprien 396
				PublicationAPersonne personneSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem();
397
				if (personneSelectionnee == null) {
1284 gduche 398
					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
399
				} else {
1428 cyprien 400
					supprimerDansGrille(personneSelectionnee);
1284 gduche 401
				}
402
			}
403
		});
404
		return bouton;
405
	}
406
 
407
	private Button creerBoutonRafraichir() {
408
		Button bouton = new Button(i18nC.rafraichir());
409
		bouton.setIcon(Images.ICONES.rafraichir());
410
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
411
			public void componentSelected(ButtonEvent ce) {
412
				actualiserGrille();
413
			}
414
		});
415
		return bouton;
416
	}
417
 
418
	private void actualiserGrille() {
419
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
420
			// FIXME : c'est la merde
421
			//mediateur.selectionner(this, null, personneSelectionnee.getId(), "%");
422
		} else {
1428 cyprien 423
			grilleAuteurs.getStore().removeAll();
1284 gduche 424
			layout();
425
		}
426
	}
427
 
1375 cyprien 428
	private void creerComboBoxPersonnesSaisies() {
429
		ModelType modelTypePersonnes = new ModelType();
430
		modelTypePersonnes.setRoot("personnes");
431
		modelTypePersonnes.setTotalName("nbElements");
432
		modelTypePersonnes.addField("cp_fmt_nom_complet");
1428 cyprien 433
		modelTypePersonnes.addField("cp_nom");
434
		modelTypePersonnes.addField("cp_prenom");
1375 cyprien 435
		modelTypePersonnes.addField("cp_id_personne");
436
		modelTypePersonnes.addField("cp_code_postal");
437
		modelTypePersonnes.addField("cp_ville");
438
		modelTypePersonnes.addField("cp_truk_courriel");
1284 gduche 439
 
1375 cyprien 440
		String displayNamePersonnes = "cp_fmt_nom_complet";
1468 jpm 441
		ProxyPersonnes<ModelData> proxyPersonnes = new ProxyPersonnes<ModelData>(null);
1375 cyprien 442
 
443
		personnesSaisiesComboBox = new ChampComboBoxRechercheTempsReelPaginable(proxyPersonnes, modelTypePersonnes, displayNamePersonnes);
444
 
445
		personnesSaisiesComboBox.getCombo().addListener(Events.Select, new Listener<BaseEvent>() {
1428 cyprien 446
			public void handleEvent(BaseEvent be) {
1375 cyprien 447
				if (personnesSaisiesComboBox.getValeur() instanceof ModelData) {
1284 gduche 448
					// N'ajouter l'auteur que s'il n'est pas déjà présent dans la grille et dans les valeurs initiales
1375 cyprien 449
					Personne personneSaisieSelectionnee = new Personne(personnesSaisiesComboBox.getValeur());
1428 cyprien 450
					PublicationAPersonne pap = new PublicationAPersonne();
451
					pap.setPersonne(personneSaisieSelectionnee);
1468 jpm 452
					pap.setOrdreAuteurs(String.valueOf(grilleAuteurs.getStore().getCount()+1));
453
					if (modeDeCreation != Formulaire.MODE_AJOUTER) {
454
						pap.setPublicationLiee(publication);
455
						pap.setIdPublication(publicationId);
456
					}
1428 cyprien 457
					if (grilleAuteurs.getStore().findModel(pap) != null)	{
1284 gduche 458
						Info.display("Information", "La personne est déjà présente dans la liste d'auteurs");
459
					} else {
1428 cyprien 460
						ajouterDansGrille(pap);
1375 cyprien 461
						personnesSaisiesComboBox.getCombo().setValue(null);
1284 gduche 462
					}
463
				}
464
			}
465
		});
466
	}
467
 
1428 cyprien 468
	private void ajouterDansGrille(PublicationAPersonne pap) {
1468 jpm 469
		ajouterDansGrille(pap, grilleAuteurs.getStore().getCount());
1284 gduche 470
	}
471
 
1428 cyprien 472
	private void ajouterDansGrille(PublicationAPersonne pap, int index) {
473
		if (pap != null) {
474
			if (!grilleAuteurs.getStore().contains(pap))	{
1284 gduche 475
				//1) si elle ne fait pas partie des initiaux, ajouter à la liste à ajouter
1428 cyprien 476
				if (!auteursInitialListe.containsValue(pap))	{
477
					auteursAjoutes.put(pap.getId(), pap);
1284 gduche 478
				}
479
 
480
				// L'enlever de la liste à supprimer
1428 cyprien 481
				if (auteursSupprimes.containsValue(pap))	{
482
					auteursSupprimes.remove(pap);
1284 gduche 483
				}
484
				//2) Ajouter a la grille
1428 cyprien 485
				grilleAuteurs.getStore().insert(pap, index);
486
				grilleAuteurs.getSelectionModel().select(index, false);
1284 gduche 487
			} else {
488
				InfoLogger.display("Information", "La personne choisie existe déjà dans la liste.");
489
			}
490
		}
491
	}
492
 
493
	/**
494
	 * Met à jour la grille avec les informations contenus dans la variable listePublicationsLiees
495
	 */
1428 cyprien 496
	/*
1284 gduche 497
	private void mettreAJourGrille()	{
498
		grille.getStore().removeAll();
499
		grille.getStore().add(listePersonne.toList());
1428 cyprien 500
	}*/
1284 gduche 501
 
1428 cyprien 502
	private void supprimerDansGrille(PublicationAPersonne pap) {
503
		if (pap != null) {
504
			// 1) Ajouter a la liste des personne à supprimer uniquement si est présente dans la liste initiale
505
			if (auteursInitialListe.containsValue(pap)) {
506
				auteursSupprimes.put(pap.getId(), pap);
1284 gduche 507
			}
508
 
1428 cyprien 509
			if (auteursAjoutes.containsValue(pap))	{
510
				auteursAjoutes.remove(pap);
1284 gduche 511
			}
512
 
1428 cyprien 513
			if (auteursModifies.containsValue(pap))	{
514
				auteursModifies.remove(pap);
515
			}
516
 
517
			// 2) Supprimer la personne de la liste
518
			grilleAuteurs.getStore().remove(pap);
1284 gduche 519
		} else {
520
			Info.display("Information", "Vous devez sélectionner une personne");
521
		}
522
	}
523
 
1428 cyprien 524
	private EditorGrid<PublicationAPersonne> creerGrilleAuteurs() {
1284 gduche 525
 
1428 cyprien 526
		ListStore<PublicationAPersonne> storeGrilleAuteurs = new ListStore<PublicationAPersonne>();
527
 
528
		// ADD Listener ------------------------------------------------------------------------------------
529
		storeGrilleAuteurs.addListener(Store.Add, new Listener<StoreEvent<PublicationAPersonne>>() {
530
			public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
531
				if (!changeOrderMarker) {
532
 
533
					// Bug de GXT : Pour récupérer l'élément modifié, j'ai dû faire comme suit
534
					ListStore<PublicationAPersonne> auteursStore = (ListStore<PublicationAPersonne>)ce.getSource();
535
					PublicationAPersonne pap = auteursStore.getAt(ce.getIndex());
536
 
537
					// Lorsque l'on reçoit une liste d'auteurs, on leur affecte l'état "modifié", puis
538
					// on les ajoute au magasin mais puisque chaque élément ajouté au magasin déclenche
539
					// l'évènement Store.Add, on est obligé de vérifier si l'objet n'a pas déjà un état
540
					// sinon l'évènement écrase l'état précédent
541
					if (pap.get("_etat_") == null) pap.set("_etat_", aDonnee.ETAT_AJOUTE);
542
 
543
					actualiserEtatBoutonsBarreOutils();
544
				}
1284 gduche 545
			}
546
		});
547
 
1428 cyprien 548
		// REMOVE Listener ------------------------------------------------------------------------------------
549
		storeGrilleAuteurs.addListener(Store.Remove, new Listener<StoreEvent<PublicationAPersonne>>() {
550
			public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
551
				if (!changeOrderMarker) {
552
					actualiserEtatBoutonsBarreOutils();
553
				}
1284 gduche 554
			}
555
		});
556
 
1428 cyprien 557
		// UPDATE Listener ------------------------------------------------------------------------------------
558
		storeGrilleAuteurs.addListener(Store.Update, new Listener<StoreEvent<PublicationAPersonne>>() {
559
			public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
560
				if (!changeOrderMarker) {
561
 
562
					if (ce.getRecord().isModified("ordre")) {
563
						/** s'il s'agit d'un auteur que l'on vient d'ajouter à la liste, alors on a pas besoin
564
						de faire quoique ce soit car l'auteur est déjà dans la liste des auteurs ajoutés **/
565
						if (ce.getModel().get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
566
							// ... do nothing
567
						/** s'il s'agit d'un auteur qui était déjà présent dans la liste initiale, il faut
568
						ajouter cet auteur à la liste des auteurs modifiés **/
569
						} else {
570
							if (ce.getModel() instanceof PublicationAPersonne) {
571
								PublicationAPersonne pap = ce.getModel();
572
								auteursModifies.put(pap.getId(), pap);
573
							}
574
						}
575
					}
1284 gduche 576
				}
577
			}
1428 cyprien 578
		});
1284 gduche 579
 
580
		List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
1428 cyprien 581
		ColumnConfig columnOrdre = new ColumnConfig("ordre", i18nC.ordre(), 15);
582
		/*
583
		final TextField<String> ordre = new TextField<String>();
584
		ordre.setValidator(new Validator(){
585
			public String validate(Field<?> field, String value) {
586
				if (value.matches("[0-9]*")) return null;
587
				else return "[Erreur] Le champ 'ordre' doit être un nombre entier.";
588
			}
589
		});
590
		*/
591
 
592
		colonnes.add(columnOrdre);
1284 gduche 593
		colonnes.add(new ColumnConfig("fmt_nom_complet", i18nC.personneNomComplet(), 150));
594
		colonnes.add(new ColumnConfig("code_postal", i18nC.personneCodePostal(), 150));
595
		colonnes.add(new ColumnConfig("ville", i18nC.personneVille(), 75));
596
		colonnes.add(new ColumnConfig("truk_courriel", i18nC.personneCourriel(), 75));
1428 cyprien 597
 
1284 gduche 598
 
1428 cyprien 599
		GridSelectionModel<PublicationAPersonne> modeleDeSelection = new GridSelectionModel<PublicationAPersonne>();
1284 gduche 600
 
601
		ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
602
 
1428 cyprien 603
		EditorGrid<PublicationAPersonne> grilleDesAuteurs = new EditorGrid<PublicationAPersonne>(storeGrilleAuteurs, modeleDeColonnes);
1284 gduche 604
 
1428 cyprien 605
		modeleDeSelection.addListener(Events.SelectionChange, new SelectionChangedListener<PublicationAPersonne>() {
606
			public void selectionChanged(SelectionChangedEvent<PublicationAPersonne> se) {
607
				PublicationAPersonne papSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem();
608
				int index = grilleAuteurs.getStore().indexOf(papSelectionnee);
609
 
610
				if (index >= 1) boutonAuteurUp.setEnabled(true);
611
				else boutonAuteurUp.setEnabled(false);
612
				if ((index+1) < grilleAuteurs.getStore().getCount()) boutonAuteurDown.setEnabled(true);
613
				else boutonAuteurDown.setEnabled(false);
614
			}
615
		});
616
 
617
		grilleDesAuteurs.setHeight("100%");
618
		grilleDesAuteurs.setBorders(true);
619
		grilleDesAuteurs.setSelectionModel(modeleDeSelection);
620
		grilleDesAuteurs.getView().setForceFit(true);
621
		grilleDesAuteurs.setAutoExpandColumn("fmt_nom_complet");
622
		grilleDesAuteurs.setStripeRows(true);
623
		grilleDesAuteurs.setTrackMouseOver(true);
624
 
625
		return grilleDesAuteurs;
1284 gduche 626
	}
627
 
1095 jpm 628
	private void genererTitreFormulaire() {
989 jpm 629
		String titre = i18nC.publicationTitreFormAjout();
822 jpm 630
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
1095 jpm 631
			 titre = i18nC.publicationTitreFormModif();
632
			 if (publication != null) {
1322 gduche 633
				 titre += " - "+i18nC.id()+": "+publication.getId()+" - "+publication.getTitre();
1095 jpm 634
			 }
822 jpm 635
		}
1095 jpm 636
		panneauFormulaire.setHeading(titre);
822 jpm 637
	}
1284 gduche 638
 
822 jpm 639
 
775 jpm 640
	private void creerZoneAuteurs() {
1329 cyprien 641
		auteursFieldset = new ContentPanel();
642
		auteursFieldset.setLayout(new FitLayout());
643
		auteursFieldset.setHeading("Auteurs");
644
 
822 jpm 645
		creerChampsAuteur();
775 jpm 646
	}
647
 
822 jpm 648
	private void creerChampsAuteur() {
775 jpm 649
		auteursFieldset.removeAll();
1284 gduche 650
		barreOutils = creerBarreOutilsGrille();
1329 cyprien 651
		auteursFieldset.setTopComponent(barreOutils);
1428 cyprien 652
		grilleAuteurs = creerGrilleAuteurs();
653
		auteursFieldset.add(grilleAuteurs);
1131 jpm 654
		auteursFieldset.layout();
775 jpm 655
	}
656
 
657
	private void creerZoneGeneralites() {
658
		FormLayout layout = new FormLayout();
659
		layout.setLabelWidth(200);
219 aurelien 660
 
661
		// Fieldset Infos Générales
775 jpm 662
		generalitesFieldset = new FieldSet();
663
		generalitesFieldset.setHeading("Informations générales");
664
		generalitesFieldset.setCollapsible(true);
665
		generalitesFieldset.setLayout(layout);
1329 cyprien 666
 
667
		ModelType modelTypeProjets = new ModelType();
668
		modelTypeProjets.setRoot("projets");
669
		modelTypeProjets.setTotalName("nbElements");
670
		modelTypeProjets.addField("cpr_nom");
671
		modelTypeProjets.addField("cpr_id_projet");
219 aurelien 672
 
1329 cyprien 673
		String displayNameProjets = "cpr_nom";
1468 jpm 674
		ProxyProjets<ModelData> proxyProjets = new ProxyProjets<ModelData>(null);
1329 cyprien 675
 
676
		projetsCombo = new ChampComboBoxRechercheTempsReelPaginable(proxyProjets, modelTypeProjets, displayNameProjets);
677
		projetsCombo.setWidth(200, 600);
678
		projetsCombo.getCombo().setTabIndex(tabIndex++);
679
		projetsCombo.getCombo().setFieldLabel(i18nC.projetChamp());
680
		projetsCombo.getCombo().setForceSelection(true);
681
		projetsCombo.getCombo().addStyleName(ComposantClass.OBLIGATOIRE);
682
		projetsCombo.getCombo().addListener(Events.Valid, Formulaire.creerEcouteurChampObligatoire());
683
 
684
		projetsCombo.getCombo().setValidator(new Validator() {
1032 jpm 685
			public String validate(Field<?> field, String value) {
686
				String retour = null;
687
				if (field.getRawValue().equals("")) {
688
					field.setValue(null);
1329 cyprien 689
				} else if (projetsCombo.getStore().findModel("cpr_nom", field.getRawValue()) == null) {
1032 jpm 690
					String contenuBrut = field.getRawValue();
691
					field.setValue(null);
692
					field.setRawValue(contenuBrut);
693
					retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
694
				}
695
				return retour;
696
			}
1329 cyprien 697
		});
698
		generalitesFieldset.add(projetsCombo, new FormData(600, 0));
1032 jpm 699
 
786 jpm 700
		titreChp = new TextField<String>();
701
		titreChp.setName("cpu");
702
		titreChp.setFieldLabel("Titre de l'article ou de l'ouvrage");
981 jpm 703
		titreChp.addStyleName(ComposantClass.OBLIGATOIRE);
980 jpm 704
		titreChp.addListener(Events.Valid, creerEcouteurChampObligatoire());
792 jpm 705
		generalitesFieldset.add(titreChp, new FormData(450, 0));
219 aurelien 706
 
786 jpm 707
		collectionChp = new TextField<String>();
792 jpm 708
		collectionChp.setFieldLabel("Intitulé de la revue ou de la collection");
709
		generalitesFieldset.add(collectionChp, new FormData(450, 0));
219 aurelien 710
 
786 jpm 711
		uriChp = new TextField<String>();
792 jpm 712
		uriChp.setFieldLabel("URL de la publication");
713
		generalitesFieldset.add(uriChp, new FormData(450, 0));
775 jpm 714
	}
715
 
716
	private void creerZoneEdition() {
717
		FormLayout layout = new FormLayout();
718
		layout.setLabelWidth(200);
719
 
219 aurelien 720
		// Fieldset Edition
775 jpm 721
		editionFieldset = new FieldSet();
792 jpm 722
		editionFieldset.setHeading("Édition");
775 jpm 723
		editionFieldset.setCollapsible(true);
724
		editionFieldset.setLayout(layout);
219 aurelien 725
 
1329 cyprien 726
		/*****************************************************/
727
		/**			Champ 'Editeur de la publication'		**/
728
		/*****************************************************/
729
		ModelType modelTypeStructures = new ModelType();
730
		modelTypeStructures.setRoot("structures");
731
		modelTypeStructures.setTotalName("nbElements");
732
		modelTypeStructures.addField("cs_nom");
733
		modelTypeStructures.addField("cs_id_structure");
219 aurelien 734
 
1329 cyprien 735
		String displayNameStructures = "cs_nom";
1468 jpm 736
		ProxyStructures<ModelData> proxyStructures = new ProxyStructures<ModelData>(null);
1329 cyprien 737
 
738
		editeurCombobox = new ChampComboBoxRechercheTempsReelPaginable(proxyStructures, modelTypeStructures, displayNameStructures);
739
		editeurCombobox.setWidth(200, 600);
740
		editeurCombobox.getCombo().setTabIndex(tabIndex++);
741
		editeurCombobox.getCombo().setEmptyText("Sélectionner un éditeur...");
742
		editeurCombobox.getCombo().setFieldLabel("Éditeur de la publication");
743
		editeurCombobox.getCombo().setEditable(true);
744
		editionFieldset.add(editeurCombobox, new FormData(600, 0));
745
 
746
		/*********************************************/
747
		/**			Champ 'Date de publication'		**/
748
		/*********************************************/
786 jpm 749
		datePublicationChp = new TextField<String>();
750
		datePublicationChp.setMaxLength(4);
751
		datePublicationChp.setMinLength(4);
752
		datePublicationChp.setFieldLabel("Année de publication");
981 jpm 753
		datePublicationChp.addStyleName(ComposantClass.OBLIGATOIRE);
980 jpm 754
		datePublicationChp.addListener(Events.Valid, creerEcouteurChampObligatoire());
792 jpm 755
		editionFieldset.add(datePublicationChp, new FormData(40, 0));
219 aurelien 756
 
1329 cyprien 757
		/*****************************/
758
		/**			Champ ''		**/
759
		/*****************************/
786 jpm 760
		tomeChp = new TextField<String>();
792 jpm 761
		tomeChp.setFieldLabel("Série de la revue ou tome");
762
		editionFieldset.add(tomeChp, new FormData(75, 0));
1329 cyprien 763
 
764
		/*****************************/
765
		/**			Champ ''		**/
766
		/*****************************/
786 jpm 767
		fasciculeChp = new TextField<String>();
792 jpm 768
		fasciculeChp.setFieldLabel("Fascicule de la revue");
769
		editionFieldset.add(fasciculeChp, new FormData(75, 0));
1329 cyprien 770
 
771
		/*****************************/
772
		/**			Champ ''		**/
773
		/*****************************/
786 jpm 774
		pagesChp = new TextField<String>();
775
		pagesChp.setFieldLabel("Pages");
887 aurelien 776
		pagesChp.setToolTip("Fomat : NBRE ou NBRE-NBRE. ('NBRE' correspond à une suite de chiffres arabes ou romains ou à un point d'interrogation '?' dans le cas d'une donnée inconnue)");
792 jpm 777
		editionFieldset.add(pagesChp, new FormData(100, 0));
219 aurelien 778
	}
1180 jpm 779
 
901 jpm 780
 
1428 cyprien 781
	 //-------------------------//
782
	//    Méthodes privées     //------------------------------------------------------------
783
 
1133 jpm 784
	private void miseAJourAuteursInitialListe() {
901 jpm 785
		Iterator<String> clesAjoutees = auteursAjoutes.keySet().iterator();
786
		while (clesAjoutees.hasNext()) {
1428 cyprien 787
			PublicationAPersonne auteurAjoute = auteursAjoutes.get(clesAjoutees.next());
1133 jpm 788
			auteursInitialListe.put(auteurAjoute.getId(), auteurAjoute);
901 jpm 789
		}
790
 
791
		Iterator<String> clesSupprimees = auteursSupprimes.keySet().iterator();
792
		while (clesSupprimees.hasNext()) {
1428 cyprien 793
			PublicationAPersonne auteurSupprime = auteursSupprimes.get(clesSupprimees.next());
1133 jpm 794
			auteursInitialListe.remove(auteurSupprime.getId());
901 jpm 795
		}
796
	}
797
 
786 jpm 798
	public boolean soumettreFormulaire() {
1322 gduche 799
		boolean formulaireValideOk = verifierFormulaire();
822 jpm 800
		if (formulaireValideOk) {
901 jpm 801
			soumettrePublication();
802
		}
803
		return formulaireValideOk;
804
	}
1322 gduche 805
 
901 jpm 806
	private void soumettrePublication() {
807
		Publication publicationCollectee = collecterPublication();
808
		if (publicationCollectee != null) {
1428 cyprien 809
			// Pour l'enregistrement des publications, on utilise le séquenceur
1322 gduche 810
			// Il doit attendre le retour de l'enregistrement pour poursuivre
811
			sequenceur = new Sequenceur();
812
			int seqId = sequenceur.lancerRequeteSynchrone(this);
901 jpm 813
			if (mode.equals(Formulaire.MODE_AJOUTER)) {
1322 gduche 814
				mediateur.ajouterPublication(sequenceur, publicationCollectee, seqId);
901 jpm 815
			} else if (mode.equals(Formulaire.MODE_MODIFIER)) {
1322 gduche 816
				mediateur.modifierPublication(sequenceur, publicationCollectee, seqId);
901 jpm 817
			}
1428 cyprien 818
 
819
		// si l'on est en mode MODIFIER, on soumet les auteurs meme si les informations de la publication
820
		// restent inchangées car il se peut que les auteurs aient été modifiés
821
		} else if (mode.equals(Formulaire.MODE_MODIFIER)) {
822
			soumettreAuteurs();
901 jpm 823
		}
824
	}
825
 
826
	private void soumettreAuteurs() {
827
 
1428 cyprien 828
		formaterOrdreAuteurs();
829
 
1284 gduche 830
		//1) Auteurs ajoutés :
1428 cyprien 831
		PublicationAPersonneListe listeAuteursAAjouter = new PublicationAPersonneListe();
1284 gduche 832
		Iterator<String> itAuteur = auteursAjoutes.keySet().iterator();
1428 cyprien 833
		while (itAuteur.hasNext())	{
1284 gduche 834
			String cle = itAuteur.next();
1428 cyprien 835
			PublicationAPersonne publiAPersonne = auteursAjoutes.get(cle);
836
			publiAPersonne.setIdPublication(this.publicationId);
837
			publiAPersonne.setOrdreAuteurs(publiAPersonne.getOrdreAuteurs());
838
			listeAuteursAAjouter.put(cle, publiAPersonne);
1284 gduche 839
		}
840
 
841
		// - envoyer au mediateur SSI personnes à ajouter
1428 cyprien 842
		if (listeAuteursAAjouter.size() > 0)	{
1322 gduche 843
			int seqId = sequenceur.lancerRequeteSynchrone(this);
1428 cyprien 844
			mediateur.ajouterPublicationAPersonne(sequenceur, this.publicationId, listeAuteursAAjouter, PublicationAPersonne.ROLE_AUTEUR, seqId);
1284 gduche 845
		}
846
 
847
		//2) Auteurs supprimés :
1428 cyprien 848
		PublicationAPersonneListe listeAuteursASupprimer = new PublicationAPersonneListe();
1284 gduche 849
		itAuteur = auteursSupprimes.keySet().iterator();
850
		while (itAuteur.hasNext())	{
851
			String cle = itAuteur.next();
1428 cyprien 852
			PublicationAPersonne publiAPersonne = auteursSupprimes.get(cle);
853
			listeAuteursASupprimer.put(cle, publiAPersonne);
1284 gduche 854
		}
855
 
856
		// - Envoyer au médiateur SSI personnes à supprimer
1428 cyprien 857
		if (listeAuteursASupprimer.size() > 0) {
1322 gduche 858
			// Pour une suppression des auteurs, on a pas besoin d'attendre le retour
1428 cyprien 859
			mediateur.supprimerPublicationAPersonne(this, listeAuteursASupprimer);
1284 gduche 860
		}
861
 
1428 cyprien 862
		//3) Auteurs modifiés :
863
		PublicationAPersonneListe listeAuteursAModifier = new PublicationAPersonneListe();
864
		itAuteur = auteursModifies.keySet().iterator();
865
		while (itAuteur.hasNext())	{
866
			String cle = itAuteur.next();
867
			PublicationAPersonne publiAPersonne = auteursModifies.get(cle);
868
			listeAuteursAModifier.put(cle, publiAPersonne);
227 aurelien 869
		}
705 aurelien 870
 
1428 cyprien 871
		// - Envoyer au médiateur SSI personnes à modifier
872
		if (listeAuteursAModifier.size() > 0) {
873
			int seqId = sequenceur.lancerRequeteSynchrone(this);
1468 jpm 874
			mediateur.modifierPublicationAPersonne(sequenceur, this.publicationId, listeAuteursAModifier, PublicationAPersonne.ROLE_AUTEUR, seqId);
705 aurelien 875
		}
876
 
1428 cyprien 877
		sequenceur.enfilerRafraichissement(this, new Information("auteurs_enregistres"));
878
	}
879
 
880
	private void formaterOrdreAuteurs() {
881
		ListStore<PublicationAPersonne> store = grilleAuteurs.getStore();
882
		List<PublicationAPersonne> auteurs = grilleAuteurs.getStore().getModels();
792 jpm 883
 
1428 cyprien 884
		Iterator<PublicationAPersonne> itAuteurs = auteurs.iterator();
885
		while (itAuteurs.hasNext())	{
886
			PublicationAPersonne pap = itAuteurs.next();
887
			int ordre = store.indexOf(pap) + 1;
888
			if (pap.getOrdreAuteurs() != String.valueOf(ordre)) {
889
				pap.setOrdreAuteurs(String.valueOf(ordre));
890
				auteursModifies.put(pap.getId(), pap);
725 aurelien 891
			}
1428 cyprien 892
		}
775 jpm 893
	}
894
 
822 jpm 895
	private void peuplerFormulaire() {
1032 jpm 896
		setValeurComboProjets();
822 jpm 897
		titreChp.setValue(publication.getTitre());
898
		collectionChp.setValue(publication.getCollection());
899
		uriChp.setValue(publication.getURI());
1032 jpm 900
		datePublicationChp.setValue(reduireDateParAnnee(publication.getDateParution()));
822 jpm 901
		tomeChp.setValue(publication.getIndicationNvt());
902
		fasciculeChp.setValue(publication.getFascicule());
903
		pagesChp.setValue(publication.getPages());
904
 
905
		if (publication.getEditeur().matches("^[0-9]+$")) {
1329 cyprien 906
			editeurCombobox.getCombo().setValue(editeurCombobox.getStore().findModel("cs_id_structure", publication.getEditeur()));
822 jpm 907
		} else {
1329 cyprien 908
			editeurCombobox.getCombo().setRawValue(publication.getEditeur());
822 jpm 909
		}
910
	}
911
 
786 jpm 912
	private Publication collecterPublication() {
1428 cyprien 913
 
786 jpm 914
		Publication publicationCollectee = (Publication) publication.cloner(new Publication());
1032 jpm 915
		publicationCollectee.setIdProjet(getValeurComboProjets());
1124 jpm 916
		publicationCollectee.setAuteur(construireIntituleAuteur());
786 jpm 917
 
918
		String titre = titreChp.getValue();
919
		publicationCollectee.setTitre(titre);
920
 
921
		String collection = collectionChp.getValue();
922
		publicationCollectee.setCollection(collection);
923
 
1124 jpm 924
		publicationCollectee.setNomComplet(construireNomComplet());
786 jpm 925
 
926
		String uri = uriChp.getValue();
927
		publicationCollectee.setUri(uri);
928
 
929
		String editeur = "";
1329 cyprien 930
		if (editeurCombobox.getValeur() != null) {
931
			Structure structure = new Structure(editeurCombobox.getValeur());
932
			editeur = structure.getId();
933
			publicationCollectee.setStructureEditeur(structure);
934
		} else if (!UtilString.isEmpty(editeurCombobox.getCombo().getRawValue())) {
935
			editeur = editeurCombobox.getCombo().getRawValue();
786 jpm 936
		}
937
		publicationCollectee.setEditeur(editeur);
938
 
792 jpm 939
		String anneePublication = datePublicationChp.getRawValue();
940
		String datePublication = anneePublication+"-00-00";
941
		publicationCollectee.setDateParution(datePublication);
786 jpm 942
 
943
		String tome = tomeChp.getValue();
944
		publicationCollectee.setIndicationNvt(tome);
945
 
946
		String fascicule = fasciculeChp.getValue();
947
		publicationCollectee.setFascicule(fascicule);
948
 
949
		String pages = pagesChp.getValue();
950
		publicationCollectee.setPages(pages);
951
 
927 jpm 952
		Publication publicationARetourner = null;
786 jpm 953
		if (!publicationCollectee.comparer(publication)) {
954
			publicationARetourner = publication = publicationCollectee;
955
		}
956
		return publicationARetourner;
957
	}
958
 
1124 jpm 959
	private String construireIntituleEditeur() {
960
		String editeur = "";
1329 cyprien 961
		if (editeurCombobox.getValeur() != null) {
962
			Structure structure = new Structure(editeurCombobox.getValeur());
1428 cyprien 963
			if (structure == null) editeur = editeurCombobox.getCombo().getRawValue();
964
			else editeur = structure.getNom();
1329 cyprien 965
		} else if (!UtilString.isEmpty(editeurCombobox.getCombo().getRawValue())) {
966
			editeur = editeurCombobox.getCombo().getRawValue();
1124 jpm 967
		}
968
		return editeur;
969
	}
970
 
971
	private String construireIntituleAuteur() {
1284 gduche 972
		String intituleAuteur = "";
973
 
1428 cyprien 974
		// ranger par ordre désigné par le champ 'cpuap_ordre' de la table PublicationAPersonne
975
		grilleAuteurs.getStore().sort("ordre", SortDir.ASC);
976
		List<PublicationAPersonne> auteurs = grilleAuteurs.getStore().getModels();
1284 gduche 977
 
1428 cyprien 978
		Iterator<PublicationAPersonne> itAuteurs = auteurs.iterator();
1284 gduche 979
		while (itAuteurs.hasNext())	{
1428 cyprien 980
			Personne personneCourante = itAuteurs.next().getPersonne();
1284 gduche 981
			intituleAuteur += personneCourante.getNom().toUpperCase() + " " + personneCourante.getPrenom();
982
			if (itAuteurs.hasNext())	{
983
				intituleAuteur+=", ";
984
			}
985
		}
986
		return intituleAuteur;
1124 jpm 987
	}
988
 
989
	private String construireNomComplet() {
990
		// Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
991
		String nomComplet = "";
992
		String auteurs = construireIntituleAuteur();
993
		String annee = datePublicationChp.getRawValue();
994
		String titre = titreChp.getValue();
995
		String editeur = construireIntituleEditeur();
996
 
997
		nomComplet += auteurs+", "+annee+". "+titre+".";
998
 
999
		if (!UtilString.isEmpty(editeur)) {
1000
			nomComplet += " Éditeur "+editeur+".";
1001
		}
1002
 
1003
		if (collectionChp.getValue() != null) {
1004
			String revue = collectionChp.getValue();
1005
			nomComplet += ", "+revue;
1006
		}
1007
 
1008
		if (fasciculeChp.getValue() != null) {
1009
			String fascicule = fasciculeChp.getValue();
1010
			nomComplet += ", "+fascicule;
1011
		}
1012
 
1013
		if (tomeChp.getValue() != null) {
1014
			String tomaison = tomeChp.getValue();
1015
			nomComplet += ", "+tomaison;
1016
		}
1017
 
1018
		if (collectionChp.getValue() != null || fasciculeChp.getValue() != null || tomeChp.getValue() != null) {
1019
			nomComplet += ".";
1020
		}
1021
 
1022
		if (pagesChp.getValue() != null) {
1023
			String pages = pagesChp.getValue();
1024
			nomComplet += pages+".";
1025
		}
1026
 
1027
		return nomComplet;
1028
	}
1029
 
934 jpm 1030
	public void reinitialiserFormulaire() {
781 jpm 1031
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
786 jpm 1032
			mediateur.afficherFormPublication(publication.getId());
775 jpm 1033
		} else {
1034
			mediateur.afficherFormPublication(null);
219 aurelien 1035
		}
1036
	}
227 aurelien 1037
 
792 jpm 1038
	private boolean etreDateValide(String anneePublication) {
782 jpm 1039
		boolean valide = true;
792 jpm 1040
		if (!anneePublication.matches("^[0-2][0-9]{3}$")) {
782 jpm 1041
			valide = false;
725 aurelien 1042
		}
782 jpm 1043
		return valide;
725 aurelien 1044
	}
758 aurelien 1045
 
1046
	private String reduireDateParAnnee(String datePar) {
775 jpm 1047
		if (datePar.matches("^[0-2][0-9]{3}(-[0-9]{2}){2}$")) {
758 aurelien 1048
			return datePar.split("-")[0];
505 jp_milcent 1049
		} else {
758 aurelien 1050
			return "";
227 aurelien 1051
		}
758 aurelien 1052
	}
1032 jpm 1053
 
1428 cyprien 1054
	 //---------------------------//
1055
	//    Méthodes publiques     //------------------------------------------------------------
1056
 
1057
	public boolean verifierFormulaire() {
1058
		boolean valide = true;
1059
		ArrayList<String> messages = new ArrayList<String>();
1060
 
1061
		// Tester si au moins un auteur est présent
1062
		if (grilleAuteurs.getStore().getModels().size() == 0) {
1063
			messages.add("Veuillez saisir au moins un auteur.");
1064
		}
1065
 
1066
		String titre = titreChp.getValue();
1067
		if (titre == null || titre.equals("")) {
1068
			messages.add("Veuillez saisir le titre de la publication !");
1069
		}
1070
 
1071
		String uri = uriChp.getValue();
1072
		if (uri != null && ! uri.isEmpty() && ! uri.matches(Pattern.url)) {
1073
			messages.add("L'URL saisie n'est pas valide !");
1074
		}
1075
 
1076
		String datePublication = datePublicationChp.getRawValue();
1077
		if (datePublication == null || datePublication.equals("")) {
1078
			messages.add("Veuillez saisir une année de parution !");
1079
		} else {
1080
			if (!etreDateValide(datePublication)) {
1081
				messages.add("Le format de l'année saisie est incorrect !");
1082
			}
1083
		}
1084
 
1085
		String pages = pagesChp.getValue();
1086
		String valeurPage = "(?:[0-9]+|[IVXLCDM]+|\\?)";
1087
		if (pages != null && ! pages.matches("^(?:"+valeurPage+"|"+valeurPage+"-"+valeurPage+")$")) {
1088
			messages.add("Le format des pages est incorrect !");
1089
		}
1090
 
1091
		if (messages.size() != 0) {
1092
			String[] tableauDeMessages = {};
1093
			tableauDeMessages = messages.toArray(tableauDeMessages);
1094
			MessageBox.alert("Erreurs de saisies", UtilArray.implode(tableauDeMessages, "<br />"), null);
1095
			valide = false;
1096
		}
1097
		return valide;
1098
	}
1099
 
1100
 
1101
	 //-------------------//
1102
	//    Accesseurs     //------------------------------------------------------------
1103
 
1032 jpm 1104
	private String getValeurComboProjets() {
1105
		String valeur = "";
1329 cyprien 1106
		if (projetsCombo.getValeur() != null) {
1107
			Projet projet = new Projet(projetsCombo.getValeur());
1108
			valeur = projet.getId();
1032 jpm 1109
		}
1110
		return valeur;
1111
	}
1112
	private void setValeurComboProjets() {
1113
		if (projetsCombo.getStore() != null ) {
1114
			if (mode.equals(Formulaire.MODE_MODIFIER) && publication != null) {
1329 cyprien 1115
				projetsCombo.getCombo().setValue(projetsCombo.getStore().findModel("cpr_id_projet", publication.getIdProjet()));
1032 jpm 1116
			} else if (mode.equals(Formulaire.MODE_AJOUTER)) {
1329 cyprien 1117
				projetsCombo.getCombo().setValue(projetsCombo.getStore().findModel("cpr_id_projet", mediateur.getProjetId()));
1032 jpm 1118
			}
1119
		}
1120
	}
1428 cyprien 1121
 
1122
	 //-------------------//
1123
	//    Rafraichir     //------------------------------------------------------------
1124
 
1125
	public void rafraichir(Object nouvellesDonnees) {
1126
		if (nouvellesDonnees instanceof Publication) {
1127
			publication = (Publication) nouvellesDonnees;
1128
		} else if (nouvellesDonnees instanceof PublicationAPersonneListe) {
1129
			rafraichirListeAuteurs((PublicationAPersonneListe) nouvellesDonnees);
1130
		} else if (nouvellesDonnees instanceof Information) {
1131
			rafraichirInformation((Information) nouvellesDonnees);
1132
		} else {
1133
			GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
1134
		}
1135
	}
1136
 
1137
	private void rafraichirListeAuteurs(PublicationAPersonneListe auteurs) {
1138
		Iterator<String> it = auteurs.keySet().iterator();
1139
		while (it.hasNext()) {
1140
			PublicationAPersonne auteur = auteurs.get(it.next());
1141
			auteur.set("_etat_", aDonnee.ETAT_MODIFIE);
1142
			auteursInitialListe.put(auteur.getId(), auteur);
1143
		}
1144
 
1145
		grilleAuteurs.getStore().removeAll();
1146
		grilleAuteurs.getStore().add(auteursInitialListe.toList());
1147
		grilleAuteurs.getStore().sort("ordre", SortDir.ASC);
1148
		layout();
1149
	}
1150
 
1151
	private void rafraichirInformation(Information info) {
1152
		String type = info.getType();
1153
 
1154
		if (type.equals("auteurs_enregistres")) {
1155
			miseAJourAuteursInitialListe();
1156
			initialiserAuteurs();
1157
			repandreRafraichissement();
1158
			controlerFermeture();
1159
		} else if (type.equals("chargement_modifier_ok"))	{
1160
			peuplerFormulaire();
1161
			genererTitreFormulaire();
1162
		}
1163
 
1164
		if (type.equals("personne_ajoutee")) {
1165
			if (info.getDonnee(0) != null) {
1166
				Personne personne = (Personne) info.getDonnee(0);
1167
				PublicationAPersonne pap = new PublicationAPersonne();
1168
				pap.setPersonne(personne);
1169
				if (modeDeCreation != Formulaire.MODE_AJOUTER) pap.setPublicationLiee(publication);
1170
				ajouterDansGrille(pap);
1171
			}
1172
		} else if (type.equals("personne_modifiee")) {
1173
			if (info.getDonnee(0) != null) {
1174
 
1175
				// créer la nouvelle entrée
1176
				Personne personne = (Personne) info.getDonnee(0);
1177
				PublicationAPersonne pap = new PublicationAPersonne();
1178
				pap.setPersonne(personne);
1179
				if (modeDeCreation != Formulaire.MODE_AJOUTER) pap.setPublicationLiee(publication);
1180
 
1181
				// supprimer l'entrée précédente
1182
				PublicationAPersonne personneDansGrille = grilleAuteurs.getStore().findModel("id_personne", personne.getId());
1183
				int index = grilleAuteurs.getStore().indexOf(personneDansGrille);
1184
				grilleAuteurs.getStore().remove(personneDansGrille);
1185
 
1186
				// ajouter la nouvelle entrée dans la grille
1187
				ajouterDansGrille(pap, index);
1188
			}
1189
		} else if (info.getType().equals("modif_publication")) {
1190
			InfoLogger.display("Modification d'une publication", info.toString());
1191
			soumettreAuteurs();
1192
		} else if (info.getType().equals("ajout_publication")) {
1193
			if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String && ((String) info.getDonnee(0)).matches("[0-9]+")) {
1194
				String idPublication = (String) info.getDonnee(0);
1195
				this.publicationId = idPublication;
1468 jpm 1196
				this.publication.setId(idPublication);
1428 cyprien 1197
				soumettreAuteurs();
1198
				InfoLogger.display("Ajout d'une publication", "La publication '"+publicationId+"' a bien été ajoutée");
1199
			} else {
1200
				InfoLogger.display("Ajout d'une publication", info.toString());
1201
			}
1202
		}
1203
	}
1204
 
1205
	private void repandreRafraichissement() {
1206
		if (vueExterneARafraichirApresValidation != null) {
1207
			String type = "publication_modifiee";
1208
			if (mode.equals(Formulaire.MODE_AJOUTER)) {
1209
				type = "publication_ajoutee";
1210
			}
1211
			Information info = new Information(type);
1212
			info.setDonnee(0, publication);
1213
			vueExterneARafraichirApresValidation.rafraichir(info);
1214
		}
1215
	}
1216
 
505 jp_milcent 1217
}