Subversion Repositories eFlore/Applications.coel

Rev

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

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