Subversion Repositories eFlore/Applications.coel

Rev

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