Subversion Repositories eFlore/Applications.coel

Rev

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

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