Subversion Repositories eFlore/Applications.coel

Rev

Rev 1262 | Rev 1323 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1262 Rev 1292
1
package org.tela_botanica.client;
1
package org.tela_botanica.client;
2
 
2
 
3
import java.util.HashMap;
3
import java.util.HashMap;
4
import java.util.Iterator;
4
import java.util.Iterator;
5
import java.util.List;
5
import java.util.List;
6
 
6
 
7
import org.tela_botanica.client.interfaces.Rafraichissable;
7
import org.tela_botanica.client.interfaces.Rafraichissable;
8
import org.tela_botanica.client.modeles.Utilisateur;
8
import org.tela_botanica.client.modeles.Utilisateur;
9
import org.tela_botanica.client.modeles.UtilisateurAsyncDao;
9
import org.tela_botanica.client.modeles.UtilisateurAsyncDao;
10
import org.tela_botanica.client.modeles.ValeurListeAsyncDao;
10
import org.tela_botanica.client.modeles.ValeurListeAsyncDao;
11
import org.tela_botanica.client.modeles.collection.Collection;
11
import org.tela_botanica.client.modeles.collection.Collection;
12
import org.tela_botanica.client.modeles.collection.CollectionACommentaire;
12
import org.tela_botanica.client.modeles.collection.CollectionACommentaire;
13
import org.tela_botanica.client.modeles.collection.CollectionACommentaireAsyncDao;
13
import org.tela_botanica.client.modeles.collection.CollectionACommentaireAsyncDao;
14
import org.tela_botanica.client.modeles.collection.CollectionAPersonne;
14
import org.tela_botanica.client.modeles.collection.CollectionAPersonne;
15
import org.tela_botanica.client.modeles.collection.CollectionAPersonneAsyncDao;
15
import org.tela_botanica.client.modeles.collection.CollectionAPersonneAsyncDao;
16
import org.tela_botanica.client.modeles.collection.CollectionAPublication;
16
import org.tela_botanica.client.modeles.collection.CollectionAPublication;
17
import org.tela_botanica.client.modeles.collection.CollectionAPublicationAsyncDao;
17
import org.tela_botanica.client.modeles.collection.CollectionAPublicationAsyncDao;
18
import org.tela_botanica.client.modeles.collection.CollectionAsyncDao;
18
import org.tela_botanica.client.modeles.collection.CollectionAsyncDao;
19
import org.tela_botanica.client.modeles.commentaire.Commentaire;
19
import org.tela_botanica.client.modeles.commentaire.Commentaire;
20
import org.tela_botanica.client.modeles.commentaire.CommentaireAsyncDao;
20
import org.tela_botanica.client.modeles.commentaire.CommentaireAsyncDao;
21
import org.tela_botanica.client.modeles.personne.Personne;
21
import org.tela_botanica.client.modeles.personne.Personne;
22
import org.tela_botanica.client.modeles.personne.PersonneAsyncDao;
22
import org.tela_botanica.client.modeles.personne.PersonneAsyncDao;
23
import org.tela_botanica.client.modeles.projet.Projet;
23
import org.tela_botanica.client.modeles.projet.Projet;
24
import org.tela_botanica.client.modeles.projet.ProjetAsyncDao;
24
import org.tela_botanica.client.modeles.projet.ProjetAsyncDao;
25
import org.tela_botanica.client.modeles.publication.Publication;
25
import org.tela_botanica.client.modeles.publication.Publication;
26
import org.tela_botanica.client.modeles.publication.PublicationAPersonne;
26
import org.tela_botanica.client.modeles.publication.PublicationAPersonne;
27
import org.tela_botanica.client.modeles.publication.PublicationAPersonneAsyncDao;
27
import org.tela_botanica.client.modeles.publication.PublicationAPersonneAsyncDao;
28
import org.tela_botanica.client.modeles.publication.PublicationAsyncDao;
28
import org.tela_botanica.client.modeles.publication.PublicationAsyncDao;
29
import org.tela_botanica.client.modeles.structure.Structure;
29
import org.tela_botanica.client.modeles.structure.Structure;
30
import org.tela_botanica.client.modeles.structure.StructureAPersonne;
30
import org.tela_botanica.client.modeles.structure.StructureAPersonne;
31
import org.tela_botanica.client.modeles.structure.StructureAPersonneAsyncDao;
31
import org.tela_botanica.client.modeles.structure.StructureAPersonneAsyncDao;
32
import org.tela_botanica.client.modeles.structure.StructureAsyncDao;
32
import org.tela_botanica.client.modeles.structure.StructureAsyncDao;
33
import org.tela_botanica.client.modeles.structure.StructureConservation;
33
import org.tela_botanica.client.modeles.structure.StructureConservation;
34
import org.tela_botanica.client.modeles.structure.StructureValorisation;
34
import org.tela_botanica.client.modeles.structure.StructureValorisation;
35
import org.tela_botanica.client.util.Debug;
35
import org.tela_botanica.client.util.Debug;
36
 
36
 
37
import com.extjs.gxt.ui.client.Registry;
37
import com.extjs.gxt.ui.client.Registry;
38
import com.google.gwt.core.client.GWT;
38
import com.google.gwt.core.client.GWT;
39
 
39
 
40
// TODO : le transformer en SINGLETON
40
// TODO : le transformer en SINGLETON
41
public class Modele {
41
public class Modele {
42
 
42
 
43
	public Modele() {
43
	public Modele() {
44
		Registry.register(RegistreId.MODELE, this);
44
		Registry.register(RegistreId.MODELE, this);
45
	}
45
	}
46
 
46
 
47
	//+----------------------------------------------------------------------------------------------------------------+
47
	//+----------------------------------------------------------------------------------------------------------------+
48
	//												GESTION DES VALEURS ET LISTES
48
	//												GESTION DES VALEURS ET LISTES
49
	//+----------------------------------------------------------------------------------------------------------------+
49
	//+----------------------------------------------------------------------------------------------------------------+
50
	
50
	
51
	public void obtenirListeValeurs(Rafraichissable vue, Integer id) {
51
	public void obtenirListeValeurs(Rafraichissable vue, Integer id) {
52
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
52
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
53
		lsDao.obtenirListe(id);
53
		lsDao.obtenirListe(id);
54
	}
54
	}
-
 
55
 
-
 
56
	public void obtenirListeValeurs(Rafraichissable vue, String type, int id) {
-
 
57
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
-
 
58
		lsDao.obtenirListe(type, String.valueOf(id));
-
 
59
	}	
-
 
60
	
-
 
61
	public void obtenirListeValeurs(Rafraichissable vue, Integer listId, boolean pagination, String recherche, int start, int nbElements) {
-
 
62
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
-
 
63
		lsDao.obtenirListe(listId, pagination, recherche, start, nbElements);
55
	
64
	}
56
	
65
	
57
	public void obtenirListeRegion(Rafraichissable vue, Integer id, String region) {
66
	public void obtenirListeRegion(Rafraichissable vue, Integer id, String region) {
58
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
67
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
59
		lsDao.selectionner("abv", id, region, null);
68
		lsDao.selectionner("abv", id, region, null);
60
	}
69
	}
61
	
70
	
62
	public void obtenirValeur(Rafraichissable vue, String type, Integer id, String identifiant) {
71
	public void obtenirValeur(Rafraichissable vue, String type, Integer id, String identifiant) {
63
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
72
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
64
		lsDao.selectionner(type, id, null, identifiant);
73
		lsDao.selectionner(type, id, null, identifiant);
65
	}
74
	}
66
	
75
	
67
	//+----------------------------------------------------------------------------------------------------------------+
76
	//+----------------------------------------------------------------------------------------------------------------+
68
	//												GESTION DES UTILISATEURS
77
	//												GESTION DES UTILISATEURS
69
	//+----------------------------------------------------------------------------------------------------------------+
78
	//+----------------------------------------------------------------------------------------------------------------+
70
	
79
	
71
	public void connecterUtilisateur(Rafraichissable vue, String login, String mdp) {
80
	public void connecterUtilisateur(Rafraichissable vue, String login, String mdp) {
72
		Utilisateur utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
81
		Utilisateur utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
73
		utilisateur.setLogin(login);
82
		utilisateur.setLogin(login);
74
		utilisateur.setMotDePasse(mdp);
83
		utilisateur.setMotDePasse(mdp);
75
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
84
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
76
		uDao.connecterUtilisateur();		
85
		uDao.connecterUtilisateur();		
77
	}
86
	}
78
	
87
	
79
	public void deconnecterUtilisateur(Rafraichissable vue) {
88
	public void deconnecterUtilisateur(Rafraichissable vue) {
80
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
89
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
81
		uDao.deconnecterUtilisateur();		
90
		uDao.deconnecterUtilisateur();		
82
	}
91
	}
83
	
92
	
84
	public void accepterLicence(Rafraichissable vue)	{
93
	public void accepterLicence(Rafraichissable vue)	{
85
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
94
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
86
		uDao.accepterLicence();
95
		uDao.accepterLicence();
87
		
96
		
88
	}
97
	}
89
	
98
	
90
	public void modifierUtilisateur(Rafraichissable vueARafraichir, Utilisateur utilisateur)	{
99
	public void modifierUtilisateur(Rafraichissable vueARafraichir, Utilisateur utilisateur)	{
91
		PersonneAsyncDao pAdao = new PersonneAsyncDao(vueARafraichir);
100
		PersonneAsyncDao pAdao = new PersonneAsyncDao(vueARafraichir);
92
		
101
		
93
		Personne personne = new Personne();
102
		Personne personne = new Personne();
94
		personne.setId(utilisateur.getId());
103
		personne.setId(utilisateur.getId());
95
		personne.setPrenom(utilisateur.getPrenom());
104
		personne.setPrenom(utilisateur.getPrenom());
96
		personne.setNom(utilisateur.getNom());
105
		personne.setNom(utilisateur.getNom());
97
		personne.setNomComplet(utilisateur.getNomComplet());
106
		personne.setNomComplet(utilisateur.getNomComplet());
98
		personne.setParametre(utilisateur.getParametre());
107
		personne.setParametre(utilisateur.getParametre());
99
		
108
		
100
		pAdao.modifier(personne);
109
		pAdao.modifier(personne);
101
	}
110
	}
102
	
111
	
103
	//+----------------------------------------------------------------------------------------------------------------+
112
	//+----------------------------------------------------------------------------------------------------------------+
104
	//												GESTION DES PROJETS
113
	//												GESTION DES PROJETS
105
	//+----------------------------------------------------------------------------------------------------------------+
114
	//+----------------------------------------------------------------------------------------------------------------+
106
	
115
	
107
	public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, String nom, int start, int nbElements) {
116
	public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, String nom, int start, int nbElements) {
108
		ProjetAsyncDao pADAO = new ProjetAsyncDao(vueARafraichir);
117
		ProjetAsyncDao pADAO = new ProjetAsyncDao(vueARafraichir);
109
		pADAO.selectionner(projetId, nom, start, nbElements);
118
		pADAO.selectionner(projetId, nom, start, nbElements);
110
	}
119
	}
111
 
120
 
112
	public void ajouterProjet(Rafraichissable vueARafraichir, Projet projetCollecte) {
121
	public void ajouterProjet(Rafraichissable vueARafraichir, Projet projetCollecte) {
113
		ProjetAsyncDao pADAO = new ProjetAsyncDao(vueARafraichir);
122
		ProjetAsyncDao pADAO = new ProjetAsyncDao(vueARafraichir);
114
		pADAO.ajouter(projetCollecte);
123
		pADAO.ajouter(projetCollecte);
115
	}
124
	}
116
 
125
 
117
	public void modifierProjet(Rafraichissable vueARafraichir, Projet projetCollecte) {
126
	public void modifierProjet(Rafraichissable vueARafraichir, Projet projetCollecte) {
118
		ProjetAsyncDao pADAO = new ProjetAsyncDao(vueARafraichir);
127
		ProjetAsyncDao pADAO = new ProjetAsyncDao(vueARafraichir);
119
		pADAO.modifier(projetCollecte);
128
		pADAO.modifier(projetCollecte);
120
	}
129
	}
121
 
130
 
122
	//+----------------------------------------------------------------------------------------------------------------+
131
	//+----------------------------------------------------------------------------------------------------------------+
123
	//												GESTION DES STRUCTURES
132
	//												GESTION DES STRUCTURES
124
	//+----------------------------------------------------------------------------------------------------------------+
133
	//+----------------------------------------------------------------------------------------------------------------+
125
 
134
 
126
	public void selectionnerStructure(Rafraichissable vueARafraichir, String projetId, String structureId, String nomStructure, int start, int nbElements) {
135
	public void selectionnerStructure(Rafraichissable vueARafraichir, String projetId, String structureId, String nomStructure, int start, int nbElements) {
127
		// Gestion des données des tables coel_structure, coel_structure_conservation et coel_structure_valorisation 
136
		// Gestion des données des tables coel_structure, coel_structure_conservation et coel_structure_valorisation 
128
		StructureAsyncDao sDao = new StructureAsyncDao(vueARafraichir);
137
		StructureAsyncDao sDao = new StructureAsyncDao(vueARafraichir);
129
		sDao.selectionner(projetId, structureId, nomStructure, start, nbElements);
138
		sDao.selectionner(projetId, structureId, nomStructure, start, nbElements);
130
	}
139
	}
131
	
140
	
132
	/** Lance la creation d'une Structure
141
	/** Lance la creation d'une Structure
133
	 * @param vueARafraichir la vue demandant a être rafraichie
142
	 * @param vueARafraichir la vue demandant a être rafraichie
134
	 * @param structure les données de la structure
143
	 * @param structure les données de la structure
135
	 */
144
	 */
136
	public void ajouterStructure(Rafraichissable vueARafraichir, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
145
	public void ajouterStructure(Rafraichissable vueARafraichir, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
137
		StructureAsyncDao structureDao = new StructureAsyncDao(vueARafraichir);
146
		StructureAsyncDao structureDao = new StructureAsyncDao(vueARafraichir);
138
		structureDao.ajouter(structure, conservation, valorisation);
147
		structureDao.ajouter(structure, conservation, valorisation);
139
	}
148
	}
140
 
149
 
141
	public void supprimerStructure(Rafraichissable vueARafraichir, String idStr) {
150
	public void supprimerStructure(Rafraichissable vueARafraichir, String idStr) {
142
		StructureAsyncDao structureDao = new StructureAsyncDao(vueARafraichir);
151
		StructureAsyncDao structureDao = new StructureAsyncDao(vueARafraichir);
143
		structureDao.supprimer(idStr);
152
		structureDao.supprimer(idStr);
144
	}
153
	}
145
	
154
	
146
	public void modifierStructure(Rafraichissable vueARafraichir, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
155
	public void modifierStructure(Rafraichissable vueARafraichir, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
147
		StructureAsyncDao structureDao = new StructureAsyncDao(vueARafraichir);
156
		StructureAsyncDao structureDao = new StructureAsyncDao(vueARafraichir);
148
		structureDao.modifier(structureId, structure, conservation, valorisation);
157
		structureDao.modifier(structureId, structure, conservation, valorisation);
149
	}
158
	}
150
 
159
 
151
	//+----------------------------------------------------------------------------------------------------------------+
160
	//+----------------------------------------------------------------------------------------------------------------+
152
	// GESTION de la relation STRUCTURE A PERSONNE
161
	// GESTION de la relation STRUCTURE A PERSONNE
153
	
162
	
154
	public void selectionnerStructureAPersonne(Rafraichissable vueARafraichir, String structureId, String roleId) {
163
	public void selectionnerStructureAPersonne(Rafraichissable vueARafraichir, String structureId, String roleId) {
155
		// Gestion des données de la table coel_structure_a_personne
164
		// Gestion des données de la table coel_structure_a_personne
156
		if (structureId != null && roleId != null) {
165
		if (structureId != null && roleId != null) {
157
			StructureAPersonneAsyncDao sapDao = new StructureAPersonneAsyncDao(vueARafraichir);
166
			StructureAPersonneAsyncDao sapDao = new StructureAPersonneAsyncDao(vueARafraichir);
158
			sapDao.selectionner(structureId, roleId);
167
			sapDao.selectionner(structureId, roleId);
159
		}
168
		}
160
	}
169
	}
161
	
170
	
162
	public void modifierStructureAPersonne(Rafraichissable vueARafraichir, StructureAPersonne personnel) {
171
	public void modifierStructureAPersonne(Rafraichissable vueARafraichir, StructureAPersonne personnel) {
163
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao(vueARafraichir);
172
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao(vueARafraichir);
164
		structureAPersonneDao.modifier(personnel);
173
		structureAPersonneDao.modifier(personnel);
165
	}
174
	}
166
	
175
	
167
	public void ajouterStructureAPersonne(Rafraichissable vueARafraichir, String structureId, StructureAPersonne personnel) {
176
	public void ajouterStructureAPersonne(Rafraichissable vueARafraichir, String structureId, StructureAPersonne personnel) {
168
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao(vueARafraichir);
177
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao(vueARafraichir);
169
		structureAPersonneDao.ajouter(structureId, personnel);	
178
		structureAPersonneDao.ajouter(structureId, personnel);	
170
	}
179
	}
171
	
180
	
172
	public void supprimerStructureAPersonne(Rafraichissable vueARafraichir, String personnelId) {
181
	public void supprimerStructureAPersonne(Rafraichissable vueARafraichir, String personnelId) {
173
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao(vueARafraichir);
182
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao(vueARafraichir);
174
		structureAPersonneDao.supprimer(personnelId);
183
		structureAPersonneDao.supprimer(personnelId);
175
	}
184
	}
176
 
185
 
177
	//+----------------------------------------------------------------------------------------------------------------+
186
	//+----------------------------------------------------------------------------------------------------------------+
178
	//												GESTION DES COLLECTIONS
187
	//												GESTION DES COLLECTIONS
179
	//+----------------------------------------------------------------------------------------------------------------+
188
	//+----------------------------------------------------------------------------------------------------------------+
180
	
189
	
181
	public void selectionnerCollection(Rafraichissable vueARafraichir, String projetId, String collectionId, String nom, int start, int nbElements) {
190
	public void selectionnerCollection(Rafraichissable vueARafraichir, String projetId, String collectionId, String nom, int start, int nbElements) {
182
		CollectionAsyncDao cDao = new CollectionAsyncDao(vueARafraichir);
191
		CollectionAsyncDao cDao = new CollectionAsyncDao(vueARafraichir);
183
		cDao.selectionner(projetId, collectionId, nom, start, nbElements);
192
		cDao.selectionner(projetId, collectionId, nom, start, nbElements);
184
	}
193
	}
185
	
194
	
186
	public void ajouterCollection(Rafraichissable vueARafraichir, Collection collection) {
195
	public void ajouterCollection(Rafraichissable vueARafraichir, Collection collection) {
187
		CollectionAsyncDao cDao = new CollectionAsyncDao(vueARafraichir);
196
		CollectionAsyncDao cDao = new CollectionAsyncDao(vueARafraichir);
188
		cDao.ajouter(collection);
197
		cDao.ajouter(collection);
189
	}
198
	}
190
 
199
 
191
	public void modifierCollection(Rafraichissable vueARafraichir, Collection collection) {
200
	public void modifierCollection(Rafraichissable vueARafraichir, Collection collection) {
192
		CollectionAsyncDao cDao = new CollectionAsyncDao(vueARafraichir);
201
		CollectionAsyncDao cDao = new CollectionAsyncDao(vueARafraichir);
193
		cDao.modifier(collection);
202
		cDao.modifier(collection);
194
	}
203
	}
195
 
204
 
196
	public void supprimerCollection(Rafraichissable vueARafraichir, String identifiantsCollectionSepareParVirgule) {
205
	public void supprimerCollection(Rafraichissable vueARafraichir, String identifiantsCollectionSepareParVirgule) {
197
		CollectionAsyncDao cDao = new CollectionAsyncDao(vueARafraichir);
206
		CollectionAsyncDao cDao = new CollectionAsyncDao(vueARafraichir);
198
		cDao.supprimer(identifiantsCollectionSepareParVirgule);
207
		cDao.supprimer(identifiantsCollectionSepareParVirgule);
199
	}
208
	}
200
	
209
	
201
	//+----------------------------------------------------------------------------------------------------------------+
210
	//+----------------------------------------------------------------------------------------------------------------+
202
	// GESTION de la relation COLLECTION A PERSONNE
211
	// GESTION de la relation COLLECTION A PERSONNE
203
	
212
	
204
	public void selectionnerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, String roleId) {
213
	public void selectionnerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, String roleId) {
205
		CollectionAPersonneAsyncDao sapDao = new CollectionAPersonneAsyncDao(vueARafraichir);
214
		CollectionAPersonneAsyncDao sapDao = new CollectionAPersonneAsyncDao(vueARafraichir);
206
		sapDao.selectionner(collectionId, roleId);
215
		sapDao.selectionner(collectionId, roleId);
207
	}
216
	}
208
	
217
	
209
	public void modifierCollectionAPersonne(Rafraichissable vueARafraichir, CollectionAPersonne collectionAPersonne) {
218
	public void modifierCollectionAPersonne(Rafraichissable vueARafraichir, CollectionAPersonne collectionAPersonne) {
210
		CollectionAPersonneAsyncDao collectionAPersonneDao = new CollectionAPersonneAsyncDao(vueARafraichir);
219
		CollectionAPersonneAsyncDao collectionAPersonneDao = new CollectionAPersonneAsyncDao(vueARafraichir);
211
		collectionAPersonneDao.modifier(collectionAPersonne);
220
		collectionAPersonneDao.modifier(collectionAPersonne);
212
	}
221
	}
213
	
222
	
214
	public void ajouterCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, CollectionAPersonne collectionAPersonne) {
223
	public void ajouterCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, CollectionAPersonne collectionAPersonne) {
215
		CollectionAPersonneAsyncDao collectionAPersonneDao = new CollectionAPersonneAsyncDao(vueARafraichir);
224
		CollectionAPersonneAsyncDao collectionAPersonneDao = new CollectionAPersonneAsyncDao(vueARafraichir);
216
		collectionAPersonneDao.ajouter(collectionId, collectionAPersonne);	
225
		collectionAPersonneDao.ajouter(collectionId, collectionAPersonne);	
217
	}
226
	}
218
	
227
	
219
	public void supprimerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionAPersonneId) {
228
	public void supprimerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionAPersonneId) {
220
		CollectionAPersonneAsyncDao collectionAPersonneDao = new CollectionAPersonneAsyncDao(vueARafraichir);
229
		CollectionAPersonneAsyncDao collectionAPersonneDao = new CollectionAPersonneAsyncDao(vueARafraichir);
221
		collectionAPersonneDao.supprimer(collectionAPersonneId);
230
		collectionAPersonneDao.supprimer(collectionAPersonneId);
222
	}
231
	}
223
	
232
	
224
	//+----------------------------------------------------------------------------------------------------------------+
233
	//+----------------------------------------------------------------------------------------------------------------+
225
	// GESTION de la relation COLLECTION A PUBLICATION
234
	// GESTION de la relation COLLECTION A PUBLICATION
226
	
235
	
227
	public void selectionnerCollectionAPublication(Rafraichissable vueARafraichir, String collectionId) {
236
	public void selectionnerCollectionAPublication(Rafraichissable vueARafraichir, String collectionId) {
228
		CollectionAPublicationAsyncDao capDao = new CollectionAPublicationAsyncDao(vueARafraichir);
237
		CollectionAPublicationAsyncDao capDao = new CollectionAPublicationAsyncDao(vueARafraichir);
229
		capDao.selectionner(collectionId);
238
		capDao.selectionner(collectionId);
230
	}
239
	}
231
	
240
	
232
	public void modifierCollectionAPublication(Rafraichissable vueARafraichir, CollectionAPublication collectionAPublication) {
241
	public void modifierCollectionAPublication(Rafraichissable vueARafraichir, CollectionAPublication collectionAPublication) {
233
		CollectionAPublicationAsyncDao collectionAPublicationDao = new CollectionAPublicationAsyncDao(vueARafraichir);
242
		CollectionAPublicationAsyncDao collectionAPublicationDao = new CollectionAPublicationAsyncDao(vueARafraichir);
234
		collectionAPublicationDao.modifier(collectionAPublication);
243
		collectionAPublicationDao.modifier(collectionAPublication);
235
	}
244
	}
236
	
245
	
237
	public void ajouterCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, CollectionAPublication collectionAPublication) {
246
	public void ajouterCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, CollectionAPublication collectionAPublication) {
238
		CollectionAPublicationAsyncDao collectionAPublicationDao = new CollectionAPublicationAsyncDao(vueARafraichir);
247
		CollectionAPublicationAsyncDao collectionAPublicationDao = new CollectionAPublicationAsyncDao(vueARafraichir);
239
		collectionAPublicationDao.ajouter(collectionId, collectionAPublication);	
248
		collectionAPublicationDao.ajouter(collectionId, collectionAPublication);	
240
	}
249
	}
241
	
250
	
242
	public void supprimerCollectionAPublication(Rafraichissable vueARafraichir, String collectionAPublicationId) {
251
	public void supprimerCollectionAPublication(Rafraichissable vueARafraichir, String collectionAPublicationId) {
243
		CollectionAPublicationAsyncDao collectionAPublicationDao = new CollectionAPublicationAsyncDao(vueARafraichir);
252
		CollectionAPublicationAsyncDao collectionAPublicationDao = new CollectionAPublicationAsyncDao(vueARafraichir);
244
		collectionAPublicationDao.supprimer(collectionAPublicationId);
253
		collectionAPublicationDao.supprimer(collectionAPublicationId);
245
	}
254
	}
246
 
255
 
247
	//+----------------------------------------------------------------------------------------------------------------+
256
	//+----------------------------------------------------------------------------------------------------------------+
248
	// GESTION de la relation COLLECTION A COMMENTAIRE
257
	// GESTION de la relation COLLECTION A COMMENTAIRE
249
	
258
	
250
	public void selectionnerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId) {
259
	public void selectionnerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId) {
251
		CollectionACommentaireAsyncDao cacDao = new CollectionACommentaireAsyncDao(vueARafraichir);
260
		CollectionACommentaireAsyncDao cacDao = new CollectionACommentaireAsyncDao(vueARafraichir);
252
		cacDao.selectionner(collectionId);
261
		cacDao.selectionner(collectionId);
253
	}
262
	}
254
	
263
	
255
	public void modifierCollectionACommentaire(Rafraichissable vueARafraichir, CollectionACommentaire collectionACommentaire) {
264
	public void modifierCollectionACommentaire(Rafraichissable vueARafraichir, CollectionACommentaire collectionACommentaire) {
256
		CollectionACommentaireAsyncDao cacDao = new CollectionACommentaireAsyncDao(vueARafraichir);
265
		CollectionACommentaireAsyncDao cacDao = new CollectionACommentaireAsyncDao(vueARafraichir);
257
		cacDao.modifier(collectionACommentaire);
266
		cacDao.modifier(collectionACommentaire);
258
	}
267
	}
259
	
268
	
260
	public void ajouterCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, CollectionACommentaire collectionACommentaire) {
269
	public void ajouterCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, CollectionACommentaire collectionACommentaire) {
261
		CollectionACommentaireAsyncDao cacDao = new CollectionACommentaireAsyncDao(vueARafraichir);
270
		CollectionACommentaireAsyncDao cacDao = new CollectionACommentaireAsyncDao(vueARafraichir);
262
		cacDao.ajouter(collectionId, collectionACommentaire);	
271
		cacDao.ajouter(collectionId, collectionACommentaire);	
263
	}
272
	}
264
	
273
	
265
	public void supprimerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionACommentaireId, String mode) {
274
	public void supprimerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionACommentaireId, String mode) {
266
		CollectionACommentaireAsyncDao cacDao = new CollectionACommentaireAsyncDao(vueARafraichir);
275
		CollectionACommentaireAsyncDao cacDao = new CollectionACommentaireAsyncDao(vueARafraichir);
267
		cacDao.supprimer(collectionACommentaireId, mode);
276
		cacDao.supprimer(collectionACommentaireId, mode);
268
	}
277
	}
269
	
278
	
270
	//+----------------------------------------------------------------------------------------------------------------+
279
	//+----------------------------------------------------------------------------------------------------------------+
271
	//												GESTION DES PERSONNES
280
	//												GESTION DES PERSONNES
272
	//+----------------------------------------------------------------------------------------------------------------+
281
	//+----------------------------------------------------------------------------------------------------------------+
273
	
282
	
274
	public void selectionnerPersonne(Rafraichissable vueARafraichir, String personneId, String projetId, String nomComplet, int start, int nbElements) {
283
	public void selectionnerPersonne(Rafraichissable vueARafraichir, String personneId, String projetId, String nomComplet, int start, int nbElements) {
275
		PersonneAsyncDao pDao = new PersonneAsyncDao(vueARafraichir);
284
		PersonneAsyncDao pDao = new PersonneAsyncDao(vueARafraichir);
276
		pDao.selectionner(personneId, projetId, nomComplet, start, nbElements);
285
		pDao.selectionner(personneId, projetId, nomComplet, start, nbElements);
277
	}
286
	}
278
 
287
 
279
	public void supprimerPersonne(Rafraichissable vueARafraichir, String idPersonneSepareParVirgule) {
288
	public void supprimerPersonne(Rafraichissable vueARafraichir, String idPersonneSepareParVirgule) {
280
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vueARafraichir);
289
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vueARafraichir);
281
		personneDao.supprimer(idPersonneSepareParVirgule);
290
		personneDao.supprimer(idPersonneSepareParVirgule);
282
		
291
		
283
	}
292
	}
284
	
293
	
285
	public void ajouterPersonne(Rafraichissable vue, Personne personne)	{
294
	public void ajouterPersonne(Rafraichissable vue, Personne personne)	{
286
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vue);
295
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vue);
287
		personneDao.ajouter(personne);
296
		personneDao.ajouter(personne);
288
	}
297
	}
289
	
298
	
290
	public void modifierPersonne(Rafraichissable vueARafraichir, Personne personne)	{
299
	public void modifierPersonne(Rafraichissable vueARafraichir, Personne personne)	{
291
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vueARafraichir);
300
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vueARafraichir);
292
		personneDao.modifier(personne);
301
		personneDao.modifier(personne);
293
	}
302
	}
294
		
303
		
295
	//+----------------------------------------------------------------------------------------------------------------+
304
	//+----------------------------------------------------------------------------------------------------------------+
296
	//												GESTION DES PUBLICATIONS
305
	//												GESTION DES PUBLICATIONS
297
	//+----------------------------------------------------------------------------------------------------------------+
306
	//+----------------------------------------------------------------------------------------------------------------+
298
	
307
	
299
	public void selectionnerPublication(Rafraichissable vueARafraichir, String publicationId, String projetId, String nomComplet, int nbElements, int pageCourante) {
308
	public void selectionnerPublication(Rafraichissable vueARafraichir, String publicationId, String projetId, String nomComplet, int nbElements, int pageCourante) {
300
		PublicationAsyncDao lsDao = new PublicationAsyncDao(vueARafraichir);
309
		PublicationAsyncDao lsDao = new PublicationAsyncDao(vueARafraichir);
301
		lsDao.selectionner(publicationId, projetId, nomComplet, nbElements, pageCourante);
310
		lsDao.selectionner(publicationId, projetId, nomComplet, nbElements, pageCourante);
302
	}
311
	}
303
	
312
	
304
	public void modifierPublication(Rafraichissable vueRafraichir, Publication publication) {
313
	public void modifierPublication(Rafraichissable vueRafraichir, Publication publication) {
305
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueRafraichir);
314
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueRafraichir);
306
		pDao.modifier(publication);
315
		pDao.modifier(publication);
307
	}
316
	}
308
 
317
 
309
	public void ajouterPublication(Rafraichissable vueARafraichir, Publication publication) {
318
	public void ajouterPublication(Rafraichissable vueARafraichir, Publication publication) {
310
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueARafraichir);
319
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueARafraichir);
311
		pDao.ajouter(publication);
320
		pDao.ajouter(publication);
312
	}
321
	}
313
 
322
 
314
	public void supprimerPublication(Rafraichissable vueARafraichir, String idPublicationSeparesParVirgule) {		
323
	public void supprimerPublication(Rafraichissable vueARafraichir, String idPublicationSeparesParVirgule) {		
315
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueARafraichir);
324
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueARafraichir);
316
		pDao.supprimer(idPublicationSeparesParVirgule);	
325
		pDao.supprimer(idPublicationSeparesParVirgule);	
317
	}
326
	}
318
 
327
 
319
	//+----------------------------------------------------------------------------------------------------------------+
328
	//+----------------------------------------------------------------------------------------------------------------+
320
	// GESTION de la relation PUBLICATION A PERSONNE
329
	// GESTION de la relation PUBLICATION A PERSONNE
321
 
330
 
322
	public void selectionPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, String roleId) {
331
	public void selectionPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, String roleId) {
323
		PublicationAPersonneAsyncDao paDao = new PublicationAPersonneAsyncDao(vueARafraichir);
332
		PublicationAPersonneAsyncDao paDao = new PublicationAPersonneAsyncDao(vueARafraichir);
324
		paDao.selectionner(publicationId, personnesId, roleId);
333
		paDao.selectionner(publicationId, personnesId, roleId);
325
	}
334
	}
326
	
335
	
327
	public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, String roleId) {
336
	public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, String roleId) {
328
		PublicationAPersonneAsyncDao paDao = new PublicationAPersonneAsyncDao(vueARafraichir);
337
		PublicationAPersonneAsyncDao paDao = new PublicationAPersonneAsyncDao(vueARafraichir);
329
		paDao.ajouter(publicationId, personnesId, roleId);
338
		paDao.ajouter(publicationId, personnesId, roleId);
330
	}
339
	}
331
 
340
 
332
	public void supprimerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationsAPersonneId) {		
341
	public void supprimerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationsAPersonneId) {		
333
		PublicationAPersonneAsyncDao publicationAPersonneDao = new PublicationAPersonneAsyncDao(vueARafraichir);
342
		PublicationAPersonneAsyncDao publicationAPersonneDao = new PublicationAPersonneAsyncDao(vueARafraichir);
334
		publicationAPersonneDao.supprimer(publicationsAPersonneId);
343
		publicationAPersonneDao.supprimer(publicationsAPersonneId);
335
	}
344
	}
336
 
345
 
337
	public void supprimerProjet(Rafraichissable vueARafraichir,
346
	public void supprimerProjet(Rafraichissable vueARafraichir,
338
			List<Projet> projetListe) {
347
			List<Projet> projetListe) {
339
		
348
		
340
		String projetsId = "";
349
		String projetsId = "";
341
		for(Iterator<Projet> it = projetListe.iterator(); it.hasNext();) {
350
		for(Iterator<Projet> it = projetListe.iterator(); it.hasNext();) {
342
			Projet proj = it.next();
351
			Projet proj = it.next();
343
			projetsId += proj.getId();
352
			projetsId += proj.getId();
344
			if(it.hasNext()) {
353
			if(it.hasNext()) {
345
				projetsId += ",";
354
				projetsId += ",";
346
			}
355
			}
347
		}
356
		}
348
		ProjetAsyncDao pADAO = new ProjetAsyncDao(vueARafraichir);
357
		ProjetAsyncDao pADAO = new ProjetAsyncDao(vueARafraichir);
349
		pADAO.supprimer(projetsId);
358
		pADAO.supprimer(projetsId);
350
	}
359
	}
351
	
360
	
352
	//+----------------------------------------------------------------------------------------------------------------+
361
	//+----------------------------------------------------------------------------------------------------------------+
353
	//												GESTION DES COMMENTAIRES
362
	//												GESTION DES COMMENTAIRES
354
	//+----------------------------------------------------------------------------------------------------------------+
363
	//+----------------------------------------------------------------------------------------------------------------+
355
	
364
	
356
	public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, String projetId, String titre, int pageCourante, int nbElements) {		
365
	public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, String projetId, String titre, int pageCourante, int nbElements) {		
357
		CommentaireAsyncDao cDao = new CommentaireAsyncDao(vueARafraichir);
366
		CommentaireAsyncDao cDao = new CommentaireAsyncDao(vueARafraichir);
358
		cDao.selectionner(commentaireId, projetId, titre, pageCourante, nbElements);
367
		cDao.selectionner(commentaireId, projetId, titre, pageCourante, nbElements);
359
	}
368
	}
360
	
369
	
361
	public void modifierCommentaire(Rafraichissable vueRafraichir, Commentaire commentaire) {
370
	public void modifierCommentaire(Rafraichissable vueRafraichir, Commentaire commentaire) {
362
		CommentaireAsyncDao cDao = new CommentaireAsyncDao(vueRafraichir);
371
		CommentaireAsyncDao cDao = new CommentaireAsyncDao(vueRafraichir);
363
		cDao.modifier(commentaire);
372
		cDao.modifier(commentaire);
364
	}
373
	}
365
 
374
 
366
	public void ajouterCommentaire(Rafraichissable vueARafraichir, Commentaire commentaire) {
375
	public void ajouterCommentaire(Rafraichissable vueARafraichir, Commentaire commentaire) {
367
		CommentaireAsyncDao cDao = new CommentaireAsyncDao(vueARafraichir);
376
		CommentaireAsyncDao cDao = new CommentaireAsyncDao(vueARafraichir);
368
		cDao.ajouter(commentaire);
377
		cDao.ajouter(commentaire);
369
	}
378
	}
370
 
379
 
371
	public void supprimerCommentaire(Rafraichissable vueARafraichir, String idCommentaireSeparesParVirgule) {
380
	public void supprimerCommentaire(Rafraichissable vueARafraichir, String idCommentaireSeparesParVirgule) {
372
		CommentaireAsyncDao cDao = new CommentaireAsyncDao(vueARafraichir);
381
		CommentaireAsyncDao cDao = new CommentaireAsyncDao(vueARafraichir);
373
		cDao.supprimer(idCommentaireSeparesParVirgule);	
382
		cDao.supprimer(idCommentaireSeparesParVirgule);	
374
	}
383
	}
375
}
384
}