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 
}