Subversion Repositories eFlore/Applications.coel

Rev

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

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