Subversion Repositories eFlore/Applications.coel

Rev

Rev 1764 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1637 aurelien 1
package org.tela_botanica.client.vues.structure;
2
 
3
import java.util.ArrayList;
4
import java.util.Collection;
5
import java.util.Iterator;
6
import java.util.List;
7
 
8
import org.tela_botanica.client.Mediateur;
9
import org.tela_botanica.client.composants.ChampComboBoxRechercheTempsReelPaginable;
10
import org.tela_botanica.client.composants.InfoLogger;
11
import org.tela_botanica.client.composants.pagination.ProxyPersonnes;
12
import org.tela_botanica.client.images.Images;
13
import org.tela_botanica.client.interfaces.Rafraichissable;
14
import org.tela_botanica.client.modeles.Information;
15
import org.tela_botanica.client.modeles.Valeur;
16
import org.tela_botanica.client.modeles.ValeurListe;
17
import org.tela_botanica.client.modeles.aDonnee;
18
import org.tela_botanica.client.modeles.personne.Personne;
1779 aurelien 19
import org.tela_botanica.client.modeles.structure.Structure;
1637 aurelien 20
import org.tela_botanica.client.modeles.structure.StructureAPersonne;
21
import org.tela_botanica.client.modeles.structure.StructureAPersonneListe;
22
import org.tela_botanica.client.synchronisation.Sequenceur;
23
import org.tela_botanica.client.util.Debug;
24
import org.tela_botanica.client.util.UtilString;
1779 aurelien 25
import org.tela_botanica.client.vues.FenetreForm;
1637 aurelien 26
import org.tela_botanica.client.vues.Formulaire;
1779 aurelien 27
import org.tela_botanica.client.vues.FormulaireBarreValidation;
1637 aurelien 28
import org.tela_botanica.client.vues.FormulaireOnglet;
1779 aurelien 29
import org.tela_botanica.client.vues.personne.PersonneForm;
1637 aurelien 30
 
31
import com.extjs.gxt.ui.client.Style.Scroll;
32
import com.extjs.gxt.ui.client.data.ModelData;
33
import com.extjs.gxt.ui.client.data.ModelType;
34
import com.extjs.gxt.ui.client.event.BaseEvent;
35
import com.extjs.gxt.ui.client.event.ButtonEvent;
36
import com.extjs.gxt.ui.client.event.ComponentEvent;
37
import com.extjs.gxt.ui.client.event.Events;
38
import com.extjs.gxt.ui.client.event.Listener;
39
import com.extjs.gxt.ui.client.event.SelectionListener;
40
import com.extjs.gxt.ui.client.store.ListStore;
41
import com.extjs.gxt.ui.client.store.Record;
42
import com.extjs.gxt.ui.client.store.Store;
43
import com.extjs.gxt.ui.client.store.StoreEvent;
44
import com.extjs.gxt.ui.client.widget.ContentPanel;
45
import com.extjs.gxt.ui.client.widget.TabItem;
1779 aurelien 46
import com.extjs.gxt.ui.client.widget.Text;
1637 aurelien 47
import com.extjs.gxt.ui.client.widget.button.Button;
1779 aurelien 48
import com.extjs.gxt.ui.client.widget.button.ButtonBar;
1637 aurelien 49
import com.extjs.gxt.ui.client.widget.form.ComboBox;
50
import com.extjs.gxt.ui.client.widget.form.Field;
1779 aurelien 51
import com.extjs.gxt.ui.client.widget.form.FormPanel;
1637 aurelien 52
import com.extjs.gxt.ui.client.widget.form.NumberField;
53
import com.extjs.gxt.ui.client.widget.form.TextArea;
54
import com.extjs.gxt.ui.client.widget.form.TextField;
55
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
56
import com.extjs.gxt.ui.client.widget.form.FormPanel.LabelAlign;
57
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
58
import com.extjs.gxt.ui.client.widget.grid.CheckColumnConfig;
59
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
60
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
61
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
62
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
63
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
1779 aurelien 64
import com.extjs.gxt.ui.client.widget.layout.FitData;
1637 aurelien 65
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
66
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
67
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
68
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
69
import com.google.gwt.core.client.GWT;
70
import com.google.gwt.i18n.client.NumberFormat;
1779 aurelien 71
import com.google.gwt.user.client.Window;
1637 aurelien 72
 
73
public class StructureFormPersonne extends FormulaireOnglet implements Rafraichissable {
74
 
75
	private StructureAPersonneListe personnel = null;
76
	private StructureAPersonneListe personnelAjoute = null;
77
	private StructureAPersonneListe personnelModifie = null;
78
	private StructureAPersonneListe personnelSupprime = null;
79
	private NumberField nbreTotalPersonneStructureChp = null;
80
	private EditorGrid<StructureAPersonne> grillePersonnel = null;
81
	private ListStore<StructureAPersonne> personnelGrilleMagazin = null;
82
 
83
	public ListStore<Valeur> fonctionsMagazin;
84
	public ComboBox<Valeur> fonctionsCombo;
85
	public ListStore<Valeur> magazinLiStatut;
86
	public ComboBox<Valeur> comboLiStatut;
87
 
88
	private ListStore<Personne> personneExistanteMagazin = null;
89
	private ChampComboBoxRechercheTempsReelPaginable personneExistanteCombo = null;
90
	private Button supprimerPersonnelBtn = null;
91
	private CellEditor fonctionEditor = null;
92
	private List<Valeur> fonctionsListe = null;
93
 
94
	private String ID = "personnel";
95
	private Formulaire formulaireCourant = null;
96
	private int decompteRafraichissementPersonnel;
97
 
1779 aurelien 98
	private FenetreForm fenetreFormulaire = null;
99
 
1637 aurelien 100
	private Sequenceur sequenceur = null;
101
 
102
	final class EtatPersonnelStructure {
103
		public StructureAPersonneListe personnelModifie;
104
		public StructureAPersonneListe personnelAjoute;
105
		public StructureAPersonneListe personnelSupprime;
106
		public StructureAPersonneListe personnel;
107
	}
108
 
109
	public StructureFormPersonne(Formulaire formulaireCourant, Mediateur mediateur) {
110
 
111
		initialiserOnglet(formulaireCourant);
112
		this.formulaireCourant = formulaireCourant;
113
 
114
		// Création des objets contenant les manipulations de la grille
115
		personnelModifie = new StructureAPersonneListe();
116
		personnelAjoute = new StructureAPersonneListe();
117
		personnelSupprime = new StructureAPersonneListe();
118
 
119
		setId(ID);
120
		setText(Mediateur.i18nC.personneSingulier());
121
		FormulaireOnglet.parametrer(this);
122
 
123
		this.setLayout(Formulaire.creerFormLayout(400, LabelAlign.LEFT));
124
		this.setStyleAttribute("padding", "0");
125
		this.addListener(Events.Select, new Listener<ComponentEvent>() {
126
			public void handleEvent(ComponentEvent be) {
127
				// Indique que l'onglet a été rempli et a pu être modifié pour la méthode collecter...
128
				setData("acces", true);
129
 
130
				// Rafraichissement du contenu de la grille du personnel
131
				if (StructureFormPersonne.this.formulaireCourant.mode.equals(Formulaire.MODE_AJOUTER)) {
132
					rafraichirPersonnel();
133
				}
134
			}
135
		});
136
 
137
		ContentPanel cp = new ContentPanel();
1680 raphael 138
		cp.setHeadingHtml("Personnes travaillant sur les collections");
1637 aurelien 139
		cp.setIcon(Images.ICONES.table());
140
		cp.setScrollMode(Scroll.AUTO);
141
		cp.setLayout(new FitLayout());
142
		//cp.setWidth(1250);
143
		//cp.setHeight("100%");
144
		cp.setFrame(true);
145
 
146
		personnelGrilleMagazin = new ListStore<StructureAPersonne>();
147
		personnelGrilleMagazin.setMonitorChanges(true);
148
 
149
		personnelGrilleMagazin.addListener(Store.Add, new Listener<StoreEvent<StructureAPersonne>>() {
150
			public void handleEvent(StoreEvent<StructureAPersonne> ce) {
151
				// Activation du bouton supprimer si la grille contient un élément
152
				if (grillePersonnel.getStore().getCount() > 0) {
153
					supprimerPersonnelBtn.enable();
154
				}
155
 
156
			}
157
		});
158
 
159
 
160
		RowNumberer r = new RowNumberer();
161
 
162
		List<ColumnConfig> configs = new ArrayList<ColumnConfig>();
163
 
164
		GridSelectionModel<StructureAPersonne> sm = new GridSelectionModel<StructureAPersonne>();
165
		configs.add(r);
166
 
167
		ColumnConfig column = new ColumnConfig("fonction", "Fonction", 150);
168
		fonctionsMagazin = new ListStore<Valeur>();
169
 
170
		fonctionsCombo = new ComboBox<Valeur>();
171
		fonctionsCombo.setTriggerAction(TriggerAction.ALL);
172
		fonctionsCombo.setEditable(true);
173
		fonctionsCombo.setDisplayField("nom");
174
		fonctionsCombo.setStore(fonctionsMagazin);
175
		mediateur.obtenirListeValeurEtRafraichir(this, "fonction", sequenceur);
176
 
177
		fonctionEditor = new CellEditor(fonctionsCombo) {
178
			@Override
179
			public Object preProcessValue(Object valeur) {
180
				Valeur retour = null;
181
 
182
				if (valeur != null) {
183
					String chaineTransmise = (String) valeur;
184
					if (fonctionsMagazin.getCount() == 0 && fonctionsListe != null) {
185
						fonctionsMagazin.add(fonctionsListe);
186
					}
187
					if (fonctionsMagazin.findModel("id_valeur", chaineTransmise) != null) {
188
						retour = fonctionsMagazin.findModel("id_valeur", chaineTransmise);
189
					} else if (fonctionsMagazin.findModel("nom", chaineTransmise) != null) {
190
						retour = fonctionsMagazin.findModel("nom", chaineTransmise);
191
					} else {
192
						retour = new Valeur("", chaineTransmise, "", "");
193
					}
194
				}
195
 
196
				return retour;
197
			}
198
 
199
			@Override
200
			public Object postProcessValue(Object valeur) {
201
				String retour = "";
202
				Valeur fonctionTrouvee = null;
203
				if (valeur == null) {
204
					String valeurBrute = this.getField().getRawValue();
205
					if (fonctionsMagazin.getCount() == 0 && fonctionsListe != null) {
206
						fonctionsMagazin.add(fonctionsListe);
207
					}
208
					if (valeurBrute.matches("^[0-9]+$") && fonctionsMagazin.findModel("id_valeur", valeurBrute) != null) {
209
						fonctionTrouvee = fonctionsMagazin.findModel("id_valeur", valeurBrute);
210
					} else {
211
						retour = valeurBrute;
212
					}
213
				} else if (valeur instanceof Valeur) {
214
					fonctionTrouvee = (Valeur) valeur;
215
				}
216
 
217
				if (fonctionTrouvee != null) {
218
					retour = fonctionTrouvee.getNom();
219
				}
220
 
221
				return retour;
222
			}
223
		};
224
		column.setEditor(fonctionEditor);
225
		configs.add(column);
226
 
227
		column = new ColumnConfig("prenom", "Prénom", 100);
228
		configs.add(column);
229
 
230
		column = new ColumnConfig("nom", "Nom", 100);
231
		configs.add(column);
232
 
1779 aurelien 233
		column = new ColumnConfig("tel_fix", "Téléphone", 100);
1637 aurelien 234
		configs.add(column);
235
 
236
		column = new ColumnConfig("tel_fax", "Fax", 100);
237
		configs.add(column);
238
 
239
		column = new ColumnConfig("courriel", "Courriel principal", 200);
240
		configs.add(column);
241
 
242
		magazinLiStatut = new ListStore<Valeur>();
243
		magazinLiStatut.add(new ArrayList<Valeur>());
244
 
245
		comboLiStatut = new ComboBox<Valeur>();
246
		comboLiStatut.setTriggerAction(TriggerAction.ALL);
247
		comboLiStatut.setEditable(false);
248
		comboLiStatut.disableTextSelection(true);
249
		comboLiStatut.setDisplayField("nom");
250
		comboLiStatut.setStore(magazinLiStatut);
251
		mediateur.obtenirListeValeurEtRafraichir(this, "statut", sequenceur);
252
 
253
		CellEditor statutEditor = new CellEditor(comboLiStatut) {
254
			@Override
255
			public Object preProcessValue(Object value) {
256
				if (value == null) {
257
					return value;
258
				}
259
				return comboLiStatut.getStore().findModel("nom", (String) value);
260
			}
261
 
262
			@Override
263
			public Object postProcessValue(Object value) {
264
				if (value == null) {
265
					return value;
266
				}
267
				return ((Valeur) value).get("nom");
268
			}
269
		};
270
		column = new ColumnConfig("statut", "Statut", 100);
271
		column.setEditor(statutEditor);
272
		configs.add(column);
273
 
274
		column = new ColumnConfig("travail", "Travail hebdo (%)", 100);
275
		column.setNumberFormat(NumberFormat.getFormat("##"));
276
		NumberField tpsWChp = new NumberField();
277
		tpsWChp.setFormat(NumberFormat.getFormat("##"));
278
		tpsWChp.setToolTip("Ce champ doit contenir un nombre");
279
		column.setEditor(new CellEditor(tpsWChp));
280
		configs.add(column);
281
 
1779 aurelien 282
		column = new ColumnConfig("specialite", "Spécialité botanique principale", 150);
1637 aurelien 283
		configs.add(column);
284
 
285
		CheckColumnConfig checkColumn = new CheckColumnConfig("contact", "Contact ?", 60);
286
		configs.add(checkColumn);
287
 
288
		ToolBar toolBar = new ToolBar();
289
 
1779 aurelien 290
 
291
		personneExistanteMagazin = new ListStore<Personne>();
292
		personneExistanteMagazin.add(new ArrayList<Personne>());
293
 
294
		ModelType modelTypePersonnes = new ModelType();
295
		modelTypePersonnes.setRoot("personnes");
296
		modelTypePersonnes.setTotalName("nbElements");
297
		modelTypePersonnes.addField("cp_fmt_nom_complet");
298
		modelTypePersonnes.addField("cp_nom");
299
		modelTypePersonnes.addField("cp_prenom");
300
		modelTypePersonnes.addField("cp_truk_courriel");
301
		modelTypePersonnes.addField("cp_truk_telephone");
302
		modelTypePersonnes.addField("cp_ce_truk_specialite");
303
		modelTypePersonnes.addField("cp_id_personne");
304
 
305
		String displayNamePersonnes = "cp_fmt_nom_complet";
306
		ProxyPersonnes<ModelData> proxyPersonnes = new ProxyPersonnes<ModelData>(null);
307
 
308
		personneExistanteCombo = new ChampComboBoxRechercheTempsReelPaginable(proxyPersonnes, modelTypePersonnes, displayNamePersonnes);
309
		personneExistanteCombo.getCombo().setEmptyText("Rechercher et sélectionner une personne existante dans la base");
310
 
311
		// TODO : dans GXT 2.0 plus besoin de l'adaptateur, on peut ajouter la combobox directement sur la toolbar
312
			//> CHECK
313
		toolBar.add(personneExistanteCombo);
314
 
315
		personneExistanteCombo.getCombo().addListener(Events.Select, new Listener<BaseEvent>() {
316
			public void handleEvent(BaseEvent be) {
317
				if (personneExistanteCombo.getValeur() instanceof ModelData) {
318
					Personne personneExistante = new Personne(personneExistanteCombo.getValeur());
319
					StructureAPersonne membreDuPersonnel = new StructureAPersonne(personneExistante, "", StructureAPersonne.ROLE_EQUIPE, StructureAPersonne.ETAT_AJOUTE);
320
					ajouterMembreAGrillePersonnel(membreDuPersonnel);
321
					personneExistanteCombo.getCombo().setValue(null);
322
				}
323
			}
1637 aurelien 324
		});
1779 aurelien 325
 
326
		toolBar.add(new Text(" ou "));
1637 aurelien 327
 
1779 aurelien 328
		Button ajouterPersonnelBtn = creerBoutonAjouter();
329
		toolBar.add(ajouterPersonnelBtn);
330
 
1637 aurelien 331
		toolBar.add(new SeparatorToolItem());
332
 
1779 aurelien 333
		Button modifierPersonnelBtn = creerBoutonModifier();
334
		toolBar.add(modifierPersonnelBtn);
335
 
336
		toolBar.add(new SeparatorToolItem());
337
 
1637 aurelien 338
		supprimerPersonnelBtn = new Button("Supprimer");
339
		supprimerPersonnelBtn.setIcon(Images.ICONES.vcardSupprimer());
340
		supprimerPersonnelBtn.addSelectionListener(new SelectionListener<ButtonEvent>() {
341
			@Override
342
			public void componentSelected(ButtonEvent ce) {
343
				StructureAPersonne personne = grillePersonnel.getSelectionModel().getSelectedItem();
344
				if (personne != null) {
345
					// Ajout de la personne supprimée à la liste
346
					if (personne.getIdPersonne() != null && !personne.getIdPersonne().equals("")) {
347
						personnelSupprime.put(personne.getId(), personne);
348
					}
349
 
350
					// Suppression de l'enregistrement de la grille
351
					grillePersonnel.getStore().remove(personne);
352
 
353
					// Désactivation du bouton supprimer si la grille contient plus d'élément
354
					if (grillePersonnel.getStore().getCount() == 0) {
355
						//TODO : check : Item -> component
356
						ce.getComponent().disable();
357
					}
358
				}
359
			}
360
		});
361
		toolBar.add(supprimerPersonnelBtn);
362
 
363
		toolBar.add(new SeparatorToolItem());
364
 
365
		Button rafraichirPersonnelBtn = new Button("Rafraichir");
366
		rafraichirPersonnelBtn.setIcon(Images.ICONES.rafraichir());
367
		rafraichirPersonnelBtn.addSelectionListener(new SelectionListener<ButtonEvent>() {
368
			@Override
369
			public void componentSelected(ButtonEvent ce) {
370
				rafraichirPersonnel();
371
			}
372
		});
373
		toolBar.add(rafraichirPersonnelBtn);
374
 
375
		toolBar.add(new SeparatorToolItem());
376
 
377
		cp.setTopComponent(toolBar);
378
 
379
		ColumnModel cm = new ColumnModel(configs);
380
 
381
		grillePersonnel = new EditorGrid<StructureAPersonne>(personnelGrilleMagazin, cm);
1779 aurelien 382
		//grillePersonnel.setHeight("100%");
383
		grillePersonnel.setAutoHeight(true);
1637 aurelien 384
		grillePersonnel.setBorders(true);
385
		grillePersonnel.setSelectionModel(sm);
386
		grillePersonnel.addPlugin(checkColumn);
387
		grillePersonnel.addPlugin(r);
388
		grillePersonnel.getView().setForceFit(true);
389
  		grillePersonnel.setAutoExpandColumn("specialite");
390
  		grillePersonnel.setStripeRows(true);
391
  		grillePersonnel.setTrackMouseOver(true);
392
 
393
 
394
		personnelGrilleMagazin.addListener(Store.Update, new Listener<StoreEvent<StructureAPersonne>>() {
395
			public void handleEvent(StoreEvent<StructureAPersonne> ce) {
396
				StructureAPersonne structureAPersonne = ce.getModel();
397
				String etat = structureAPersonne.get("etat");
398
				if ((etat==null || !etat.equals(aDonnee.ETAT_AJOUTE)) && structureAPersonne!=null && !UtilString.isEmpty(structureAPersonne.getId()))	{
399
					ce.getModel().set("etat", aDonnee.ETAT_MODIFIE);
400
				}
401
			}
402
		});
403
 
404
 
405
  		cp.add(grillePersonnel);
406
		this.add(cp);
1779 aurelien 407
 
408
		this.setAutoHeight(true);
1637 aurelien 409
	}
410
 
1779 aurelien 411
	private Button creerBoutonAjouter() {
412
		Button bouton = new Button(i18nC.ajouter());
413
		bouton.setIcon(Images.ICONES.vcardAjouter());
414
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
415
			public void componentSelected(ButtonEvent ce) {
416
				fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_AJOUTER);
417
				fenetreFormulaire.show();
418
			}
419
		});
420
		return bouton;
421
	}
422
 
423
	private Button creerBoutonModifier() {
424
		Button bouton = new Button(i18nC.modifier());
425
		bouton.setIcon(Images.ICONES.vcardModifier());
426
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
427
			public void componentSelected(ButtonEvent ce) {
428
				String IdpersonneSaisieSelectionnee = (grillePersonnel.getSelectionModel().getSelectedItem()).getIdPersonne();
429
 
430
				if (IdpersonneSaisieSelectionnee == null) {
431
					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPersonne());
432
				} else {
433
					fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_MODIFIER);
434
					fenetreFormulaire.show();
435
				}
436
			}
437
		});
438
		return bouton;
439
	}
440
 
441
	private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
442
		String personneId = null;
443
		if (mode.equals(Formulaire.MODE_MODIFIER)) {
444
			personneId = (grillePersonnel.getSelectionModel().getSelectedItem()).getIdPersonne();
445
		}
446
 
447
		final FenetreForm fenetre = new FenetreForm("");
448
		final PersonneForm formulaire = creerFormulairePersonne(fenetre, personneId);
449
		fenetre.add(formulaire);
450
		return fenetre;
451
	}
452
 
453
	private PersonneForm creerFormulairePersonne(final FenetreForm fenetre, final String personneId) {
454
		PersonneForm formulairePersonne = new PersonneForm(mediateur, personneId, this);
455
		FormPanel panneauFormulaire = formulairePersonne.getFormulaire();
456
		fenetre.setHeadingHtml(panneauFormulaire.getHeadingHtml());
457
		panneauFormulaire.setHeaderVisible(false);
458
		panneauFormulaire.setTopComponent(null);
459
 
460
		// 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.
461
		panneauFormulaire.getBottomComponent().hide();
462
		SelectionListener<ButtonEvent> ecouteur = creerEcouteurValidationFormulairePersonne(fenetre, formulairePersonne);
463
		final ButtonBar barreValidation = new FormulaireBarreValidation(ecouteur);
464
		fenetre.setBottomComponent(barreValidation);
465
 
466
		return formulairePersonne;
467
	}
468
 
469
	private SelectionListener<ButtonEvent> creerEcouteurValidationFormulairePersonne(final FenetreForm fenetre, final PersonneForm formulaire) {
470
		SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
471
			public void componentSelected(ButtonEvent ce) {
472
				String code = ((Button) ce.getComponent()).getData("code");
473
				if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
474
					if (formulaire.soumettreFormulaire()) {
475
						fenetre.hide();
476
					}
477
				} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
478
					formulaire.soumettreFormulaire();
479
				} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
480
					fenetre.hide();
481
				}
482
			}
483
		};
484
 
485
		return ecouteur;
486
	}
487
 
1637 aurelien 488
	public Collection<? extends String> verifier() {
489
		ArrayList<String> messages = new ArrayList<String>();
490
		// Vérification du Personnel
491
		if (getData("acces").equals(true)) {
492
			String personnelNumero = "";
493
			int nbrePersonne = personnelGrilleMagazin.getCount();
494
			for (int i = 0; i < nbrePersonne; i++) {
495
				StructureAPersonne personne = personnelGrilleMagazin.getAt(i);
496
				if (personne.getNom().equals("") || personne.getPrenom().equals("")) {
497
					personnelNumero += (i != 0 ? ", " : "")+(i+1);
498
				}
499
			}
500
			if (!personnelNumero.equals("")) {
501
				messages.add("Veuillez indiquez un prénom et un nom au personnel numéro : "+personnelNumero);
502
			}
503
		}
504
		return messages;
505
	}
506
 
507
	@Override
508
	public void rafraichir(Object nouvellesDonnees) {
509
		if (nouvellesDonnees instanceof ValeurListe) {
510
			ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
511
			rafraichirValeurListe(listeValeurs);
512
		} else if (nouvellesDonnees instanceof Information) {
513
			Information info = (Information) nouvellesDonnees;
514
			rafraichirInformation(info);
515
		} else {
516
			Debug.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()));
517
		}
518
	}
519
 
520
	public void rafraichirInformation(Information info) {
521
		if (info.getType().equals("ajout_structure")) {
522
			if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String) {
523
				String structureId = (String) info.getDonnee(0);
524
				// Suite à la récupération de l'id de l'institution nouvellement ajoutée nous ajoutons le personnel
525
				mediateur.ajouterStructureAPersonne(this, structureId, getPersonnelAjoute());
526
			}
527
		} else if (info.getType().equals("modif_structure_a_personne")) {
528
			InfoLogger.display("Modification du Personnel", info.toString());
529
			testerLancementRafraichirPersonnel();
530
		} else if (info.getType().equals("suppression_structure_a_personne")) {
531
			InfoLogger.display("Suppression du Personnel", info.toString());
532
			testerLancementRafraichirPersonnel();
533
		} else if (info.getType().equals("ajout_structure_a_personne")) {
534
			InfoLogger.display("Ajout du Personnel", info.toString());
535
			testerLancementRafraichirPersonnel();
536
		} else if (info.getType().equals("liste_structure_a_personne")) {
537
			if (info.getDonnee(0) != null) {
538
				StructureAPersonneListe personnel = (StructureAPersonneListe) info.getDonnee(0);
539
				peupler(personnel);
540
				layout();
541
				InfoLogger.display("Chargement du Personnel", "ok");
542
			}
1779 aurelien 543
		} else if (info.getType().equals("personne_modifiee")) {
544
			if (info.getDonnee(0) != null) {
545
				Personne personne = (Personne) info.getDonnee(0);
546
				StructureAPersonne personneDansGrille = grillePersonnel.getStore().findModel("id_personne", personne.getId());
547
				StructureAPersonne personneDansGrilleModif = new StructureAPersonne(personne, personneDansGrille.getFonction(), personneDansGrille.getIdRole(), personneDansGrille.getIdEtat());
548
				int index = grillePersonnel.getStore().indexOf(personneDansGrille);
549
				grillePersonnel.getStore().remove(personneDansGrille);
550
				grillePersonnel.getStore().insert(personneDansGrilleModif, index);
551
				personnelModifie.put(personne.getId()+"", personneDansGrilleModif);
552
			}
553
		} else if (info.getType().equals("personne_ajoutee")) {
554
			if (info.getDonnee(0) != null) {
555
				Personne personne = (Personne) info.getDonnee(0);
556
				StructureAPersonne structAPersonne = new StructureAPersonne(personne,"",StructureAPersonne.ROLE_EQUIPE, "");
557
				Structure structure = ((StructureForm) formulaire).identification;
558
				structAPersonne.setIdStructure(structure.getId());
559
				personnelAjoute.put(personne.getId(), structAPersonne);
560
				ajouterMembreAGrillePersonnel(structAPersonne);
561
			}
1637 aurelien 562
		}
563
	}
564
 
565
	public void rafraichirValeurListe(ValeurListe listeValeurs) {
566
		List<Valeur> liste = listeValeurs.toList();
567
		if (listeValeurs.getId().equals(config.getListeId("statut"))) {
568
			magazinLiStatut.removeAll();
569
			magazinLiStatut.add(liste);
570
			comboLiStatut.setStore(magazinLiStatut);
571
		}
572
		if (listeValeurs.getId().equals(config.getListeId("fonction"))) {
573
			// FIXME : le store ne contient pas tout le temps les données, chose étrange.
574
			// On stocke donc les données dans une variables de la classe pour recharger le store si besoin.
575
			fonctionsListe = liste;
576
			fonctionsMagazin.removeAll();
577
			fonctionsMagazin.add(liste);
578
			fonctionsCombo.setStore(fonctionsMagazin);
579
		}
580
	}
581
 
582
	public EtatPersonnelStructure collecter() {
583
		StructureForm formulaire = (StructureForm)formulaireCourant;
584
 
585
		if (getData("acces").equals(true)) {
586
			personnelGrilleMagazin.commitChanges();
587
			int nbrePersonne = personnelGrilleMagazin.getCount();
588
			for (int i = 0; i < nbrePersonne; i++) {
589
				StructureAPersonne personne = personnelGrilleMagazin.getAt(i);
590
 
591
				// Seules les lignes ajoutées ou modifiées sont prises en compte.
592
				Record record = personnelGrilleMagazin.getRecord(personne);
593
				if (personnelGrilleMagazin.getModifiedRecords().contains(record) == true
594
						|| (personne.get("etat") != null && (personne.get("etat").equals(StructureAPersonne.ETAT_AJOUTE) || personne.get("etat").equals(StructureAPersonne.ETAT_MODIFIE)) )) {
595
 
596
					// Gestion de l'id de la structure
597
					if (mode.equals("MODIF")) {
598
						personne.setIdStructure(getIdIdentification());
599
					}
600
 
601
					// Gestion de la fonction
602
					String fonction = personne.get("fonction");
603
					if (fonction != null && !fonction.equals("")) {
604
						Valeur valeurRecherche = fonctionsCombo.getStore().findModel("nom", fonction);
605
						if (valeurRecherche != null) {
606
							personne.setFonction(valeurRecherche.getId());
607
						} else {
608
							personne.setFonction("AUTRE", fonction);
609
						}
610
					} else {
611
						personne.setFonction("");
612
					}
613
 
614
					// Gestion du nom complet
615
					String nomComplet = personne.getPrenom()+" "+personne.getNom();
616
					personne.setNomComplet(nomComplet);
617
 
618
					// Gestion de la notion de "contact"
619
					personne.setContact(false);
620
					if (personne.get("contact").equals(true)) {
621
						personne.setContact(true);
622
					}
623
 
624
					// Gestion du statut
625
					String statut = personne.get("statut");
626
					if (statut != null && !statut.equals("")) {
627
						Valeur valeurRecherche = comboLiStatut.getStore().findModel("nom", statut);
628
						if (valeurRecherche != null) {
629
							personne.setStatut(valeurRecherche.getId());
630
						} else {
631
							personne.setStatut("AUTRE", statut);
632
						}
633
					} else {
634
						personne.setStatut("");
635
					}
636
 
637
					// Gestion du temps de travail
638
					String personneTravail = "";
639
					if(personne.get("travail") != null) {
640
						personneTravail = personne.get("travail").toString();
641
					}
642
					personne.setBotaTravailHebdoTps(personneTravail);
643
 
644
					// Gestion du téléphone
645
					String telephoneFixe = personne.get("tel_fix");
646
					personne.setTelephoneFixe(telephoneFixe);
647
 
648
					// Gestion du fax
649
					String fax = personne.get("tel_fax");
650
					personne.setFax(fax);
651
 
652
					// Gestion du courriel
653
					String courriel = personne.get("courriel");
654
					personne.setCourriel(courriel);
655
 
656
					// Gestion de la spécialité
657
					String specialite = personne.get("specialite");
658
					personne.setSpecialite(specialite);
659
 
660
					// On met à faux le décès
661
					personne.setDeces(Personne.ETRE_VIVANT);
662
 
663
					// Ajout de la personne dans la liste correspondant à son état (ajouté ou modifié)
1779 aurelien 664
					if (personne.get("etat") != null && personne.get("etat").equals(StructureAPersonne.ETAT_AJOUTE)) { // Une personne ajoutée
1637 aurelien 665
						personnelAjoute.put(""+i, personne);
666
					} else {// Une personne modifiée
667
						personnelModifie.put(personne.getId(), personne);
668
					}
669
				} else {
670
					GWT.log("Personne non modifiées : "+personne.getPrenom()+" "+personne.getNom(), null);
671
				}
672
			}
673
		}
674
 
675
		EtatPersonnelStructure etatPersonnel = new EtatPersonnelStructure();
676
		etatPersonnel.personnelAjoute = personnelAjoute;
677
		etatPersonnel.personnelModifie = personnelModifie;
678
		etatPersonnel.personnelSupprime = personnelSupprime;
679
 
680
		// Remise à zéro des modification dans la liste du personnel
681
		personnelModifie = new StructureAPersonneListe();
682
		personnelAjoute = new StructureAPersonneListe();
683
		personnelSupprime = new StructureAPersonneListe();
684
 
685
		return etatPersonnel;
686
	}
687
 
688
	public void peupler(StructureAPersonneListe personnel) {
689
		//this.personnel = personnel;
690
		if (formulaireCourant.mode.equals(Formulaire.MODE_MODIFIER) && personnel != null) {
691
			ArrayList<StructureAPersonne> personnes = new ArrayList<StructureAPersonne>();
692
			for (Iterator<String> it = personnel.keySet().iterator(); it.hasNext();) {
693
				String index = it.next();
694
 
695
				// Gestion de la fonction
696
				if (fonctionsMagazin != null && !((String) personnel.get(index).getFonction()).startsWith("AUTRE##")) {
697
					if (fonctionsMagazin.findModel("id_valeur", personnel.get(index).getFonction()) != null) {
698
						personnel.get(index).set("fonction", fonctionsMagazin.findModel("id_valeur", personnel.get(index).getFonction()).getNom());
699
					}
700
				} else {
701
					personnel.get(index).set("fonction", personnel.get(index).getFonction().replaceFirst("AUTRE##", ""));
702
				}
703
 
704
				// Gestion de la notion de "contact"
705
				personnel.get(index).set("contact", (personnel.get(index).getContact().equals("1") ? true : false));
706
 
707
				// Gestion du statut
708
				if (magazinLiStatut != null && ((String) personnel.get(index).getStatut()).matches("^[0-9]+$")) {
709
					personnel.get(index).set("statut", magazinLiStatut.findModel("id_valeur", personnel.get(index).getStatut()).getNom());
710
				} else {
711
					personnel.get(index).set("statut", personnel.get(index).getStatut().replaceFirst("AUTRE##", ""));
712
				}
713
				// Gestion de la specialite
714
				if (((String) personnel.get(index).getSpecialite()).matches("^[0-9]+$")) {
715
					// Author : Cyprien
716
					// TODO
717
					// Ici faire un combobox ?
718
					// ...
719
				} else {
720
					personnel.get(index).set("specialite", personnel.get(index).getSpecialite().replaceFirst("AUTRE##", ""));
721
				}
722
 
723
				// Gestion du temps de travail
724
				String tps = personnel.get(index).getBotaTravailHebdoTps();
725
				personnel.get(index).set("travail", (tps.matches("^[0-9]+$")  ? Integer.parseInt(tps) : 0));
726
 
727
				personnes.add(personnel.get(index));
728
			}
729
			personnelGrilleMagazin.removeAll();
730
			personnelGrilleMagazin.add(personnes);
731
 
732
			// Remise à zéro des modification dans la liste du personnel
733
			personnelModifie = new StructureAPersonneListe();
734
			personnelAjoute = new StructureAPersonneListe();
735
			personnelSupprime = new StructureAPersonneListe();
736
 
737
			// Nous vidons la variable personnel une fois qu'elle a remplie la grille
738
			personnel = null;
739
		}
740
	}
741
 
742
	public StructureAPersonneListe getPersonnelAjoute() {
743
		return personnelAjoute;
744
	}
745
 
746
	private void ajouterMembreAGrillePersonnel(StructureAPersonne personnel) {
747
		grillePersonnel.stopEditing();
748
		personnelGrilleMagazin.insert(personnel, 0);
749
		grillePersonnel.startEditing(0, 0);
750
	}
751
 
752
	public void testerLancementRafraichirPersonnel() {
753
		decompteRafraichissementPersonnel--;
754
		if (decompteRafraichissementPersonnel <= 0) {
755
			// Nous rechargeons la liste du Personnel
756
			rafraichirPersonnel();
757
		}
758
	}
759
 
760
	private void rafraichirPersonnel() {
761
		decompteRafraichissementPersonnel = 0;
762
		if (formulaireCourant.mode.equals(Formulaire.MODE_MODIFIER)) {
763
			initialiserGrillePersonnelEnModification();
764
		} else if (formulaireCourant.mode.equals(Formulaire.MODE_AJOUTER)) {
765
			initialiserGrillePersonnelEnAjout();
766
		}
767
	}
768
 
769
	private void rafraichirPersonneExistante(String nom) {
1764 aurelien 770
		mediateur.selectionnerPersonneParNomComplet(this, nom+"%", null);
1637 aurelien 771
	}
772
 
773
	public void incrementerDecompteRafraichissementPersonnel() {
774
		decompteRafraichissementPersonnel++;
775
	}
776
 
777
	private void initialiserGrillePersonnelEnAjout() {
778
		personnelGrilleMagazin.removeAll();
779
		layout();
780
	}
781
 
782
	private String getIdIdentification() {
783
		return ((StructureForm)formulaireCourant).getIdIdentification();
784
	}
785
 
786
	private void initialiserGrillePersonnelEnModification() {
787
		mediateur.selectionnerStructureAPersonne(this, getIdIdentification(), StructureAPersonne.ROLE_EQUIPE, null);
788
	}
789
}