Subversion Repositories eFlore/Applications.coel

Rev

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

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