Subversion Repositories eFlore/Applications.coel

Rev

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

Rev 453 Rev 468
1 
package org.tela_botanica.client;
 1 
package org.tela_botanica.client;
2 
 
 2 
 
3 
import java.util.Iterator;
 3 
import java.util.Iterator;
4 
import java.util.List;
 4 
import java.util.List;
5 
 
 5 
 
6 
import org.tela_botanica.client.interfaces.Rafraichissable;
 6 
import org.tela_botanica.client.interfaces.Rafraichissable;
7 
import org.tela_botanica.client.modeles.Collection;
 7 
import org.tela_botanica.client.modeles.Collection;
- 
 
 8 
import org.tela_botanica.client.modeles.CollectionAsyncDao;
8 
import org.tela_botanica.client.modeles.Personne;
 9 
import org.tela_botanica.client.modeles.Personne;
9 
import org.tela_botanica.client.modeles.PersonneAsyncDao;
 10 
import org.tela_botanica.client.modeles.PersonneAsyncDao;
10 
import org.tela_botanica.client.modeles.ProjetAsyncDao;
 11 
import org.tela_botanica.client.modeles.ProjetAsyncDao;
11 
import org.tela_botanica.client.modeles.Publication;
 12 
import org.tela_botanica.client.modeles.Publication;
12 
import org.tela_botanica.client.modeles.PublicationAsyncDao;
 13 
import org.tela_botanica.client.modeles.PublicationAsyncDao;
13 
import org.tela_botanica.client.modeles.Structure;
 14 
import org.tela_botanica.client.modeles.Structure;
14 
import org.tela_botanica.client.modeles.StructureAPersonne;
 15 
import org.tela_botanica.client.modeles.StructureAPersonne;
15 
import org.tela_botanica.client.modeles.StructureAPersonneAsyncDao;
 16 
import org.tela_botanica.client.modeles.StructureAPersonneAsyncDao;
16 
import org.tela_botanica.client.modeles.StructureAsyncDao;
 17 
import org.tela_botanica.client.modeles.StructureAsyncDao;
17 
import org.tela_botanica.client.modeles.StructureConservation;
 18 
import org.tela_botanica.client.modeles.StructureConservation;
18 
import org.tela_botanica.client.modeles.StructureValorisation;
 19 
import org.tela_botanica.client.modeles.StructureValorisation;
19 
import org.tela_botanica.client.modeles.Utilisateur;
 20 
import org.tela_botanica.client.modeles.Utilisateur;
20 
import org.tela_botanica.client.modeles.UtilisateurAsyncDao;
 21 
import org.tela_botanica.client.modeles.UtilisateurAsyncDao;
21 
import org.tela_botanica.client.modeles.ValeurListeAsyncDao;
 22 
import org.tela_botanica.client.modeles.ValeurListeAsyncDao;
22 
import org.tela_botanica.client.vues.ContenuVue;
 23 
import org.tela_botanica.client.vues.ContenuVue;
23 
 
 24 
 
24 
import com.extjs.gxt.ui.client.Registry;
 25 
import com.extjs.gxt.ui.client.Registry;
25 
import com.google.gwt.core.client.GWT;
 26 
import com.google.gwt.core.client.GWT;
26 
 
 27 
 
27 
// TODO : le transformer en SINGLETON
 28 
// TODO : le transformer en SINGLETON
28 
public class Modele {
 29 
public class Modele {
29 
 
 30 
 
30 
	public Modele() {
 31 
	public Modele() {
31 
		Registry.register(RegistreId.MODELE, this);
 32 
		Registry.register(RegistreId.MODELE, this);
32 
	}
 33 
	}
33 
 
 34 
 
34 
	//+----------------------------------------------------------------------------------------------------------------+
 35 
	//+----------------------------------------------------------------------------------------------------------------+
35 
	//												GESTION DES VALEURS ET LISTES
 36 
	//												GESTION DES VALEURS ET LISTES
36 
	//+----------------------------------------------------------------------------------------------------------------+
 37 
	//+----------------------------------------------------------------------------------------------------------------+
37
38
38 
	public void obtenirListeValeurs(Rafraichissable vue, Integer id) {
 39 
	public void obtenirListeValeurs(Rafraichissable vue, Integer id) {
39 
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
 40 
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
40 
		lsDao.obtenirListe(id);
 41 
		lsDao.obtenirListe(id);
41 
	}
 42 
	}
42
43
43
44
44 
	public void obtenirListeRegion(Rafraichissable vue, Integer id, String region) {
 45 
	public void obtenirListeRegion(Rafraichissable vue, Integer id, String region) {
45 
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
 46 
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
46 
		lsDao.selectionner("abv", id, null, region);
 47 
		lsDao.selectionner("abv", id, null, region);
47 
	}
 48 
	}
48
49
49 
	public void obtenirValeur(Rafraichissable vue, String type, Integer id, String identifiant) {
 50 
	public void obtenirValeur(Rafraichissable vue, String type, Integer id, String identifiant) {
50 
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
 51 
		ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(vue);
51 
		lsDao.selectionner(type, id, null, identifiant);
 52 
		lsDao.selectionner(type, id, null, identifiant);
52 
	}
 53 
	}
53
54
54 
	//+----------------------------------------------------------------------------------------------------------------+
 55 
	//+----------------------------------------------------------------------------------------------------------------+
55 
	//												GESTION DES UTILISATEURS
 56 
	//												GESTION DES UTILISATEURS
56 
	//+----------------------------------------------------------------------------------------------------------------+
 57 
	//+----------------------------------------------------------------------------------------------------------------+
57
58
58 
	public void connecterUtilisateur(Rafraichissable vue, String login, String mdp) {
 59 
	public void connecterUtilisateur(Rafraichissable vue, String login, String mdp) {
59 
		Utilisateur utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
 60 
		Utilisateur utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
60 
		utilisateur.setLogin(login);
 61 
		utilisateur.setLogin(login);
61 
		utilisateur.setMotDePasse(mdp);
 62 
		utilisateur.setMotDePasse(mdp);
62 
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
 63 
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
63 
		uDao.connecterUtilisateur();
64 
		uDao.connecterUtilisateur();
64 
	}
 65 
	}
65
66
66 
	public void deconnecterUtilisateur(Rafraichissable vue) {
 67 
	public void deconnecterUtilisateur(Rafraichissable vue) {
67 
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
 68 
		UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
68 
		uDao.deconnecterUtilisateur();
69 
		uDao.deconnecterUtilisateur();
69 
	}
 70 
	}
70
71
71 
	//+----------------------------------------------------------------------------------------------------------------+
 72 
	//+----------------------------------------------------------------------------------------------------------------+
72 
	//												GESTION DES PROJETS
 73 
	//												GESTION DES PROJETS
73 
	//+----------------------------------------------------------------------------------------------------------------+
 74 
	//+----------------------------------------------------------------------------------------------------------------+
74
75
75 
	public void selectionnerProjets(Rafraichissable vue)	{
 76 
	public void selectionnerProjets(Rafraichissable vue)	{
76 
		ProjetAsyncDao projetsDao = new ProjetAsyncDao(vue);
 77 
		ProjetAsyncDao projetsDao = new ProjetAsyncDao(vue);
77 
		projetsDao.selectionner();
 78 
		projetsDao.selectionner();
78 
	}
 79 
	}
79 
 
 80 
 
80 
	//+----------------------------------------------------------------------------------------------------------------+
 81 
	//+----------------------------------------------------------------------------------------------------------------+
81 
	//												GESTION DES STRUCTURES
 82 
	//												GESTION DES STRUCTURES
82 
	//+----------------------------------------------------------------------------------------------------------------+
 83 
	//+----------------------------------------------------------------------------------------------------------------+
83 
 
 84 
 
84 
	public void obtenirListeStructures(Rafraichissable vue, String projetId) {
 85 
	public void obtenirListeStructures(Rafraichissable vueARafraichir, String projetId) {
85 
		StructureAsyncDao sDao = new StructureAsyncDao();
 86 
		StructureAsyncDao sDao = new StructureAsyncDao();
86 
		sDao.selectionner(vue, projetId, "");
 87 
		sDao.selectionner(vueARafraichir, projetId, "");
87 
	}
 88 
	}
88
89
89 
	public void selectionnerStructure(Rafraichissable vue, String projetId, String structureId) {
 90 
	public void selectionnerStructure(Rafraichissable vueARafraichir, String projetId, String structureId) {
90 
		// Gestion des données des tables coel_structure, coel_structure_conservation et coel_structure_valorisation
91 
		// Gestion des données des tables coel_structure, coel_structure_conservation et coel_structure_valorisation
91 
		StructureAsyncDao sDao = new StructureAsyncDao();
 92 
		StructureAsyncDao sDao = new StructureAsyncDao();
92 
		sDao.selectionner(vue, projetId, structureId);
 93 
		sDao.selectionner(vueARafraichir, projetId, structureId);
93 
	}
 94 
	}
94
95
95 
	/** Lance la creation d'une Structure
 96 
	/** Lance la creation d'une Structure
96 
	 * @param vue la vue demandant a être rafraichie
 97 
	 * @param vueARafraichir la vue demandant a être rafraichie
97 
	 * @param structure les données de la structure
 98 
	 * @param structure les données de la structure
98 
	 */
 99 
	 */
99 
	public void ajouterStructure(Rafraichissable vue, String idUtilisateur, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
 100 
	public void ajouterStructure(Rafraichissable vueARafraichir, String idUtilisateur, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
100 
		StructureAsyncDao structureDao = new StructureAsyncDao();
 101 
		StructureAsyncDao structureDao = new StructureAsyncDao();
101 
		structureDao.ajouter(vue, idUtilisateur, structure, conservation, valorisation);
 102 
		structureDao.ajouter(vueARafraichir, idUtilisateur, structure, conservation, valorisation);
102 
	}
 103 
	}
103 
 
 104 
 
104 
	public void supprimerStructure(Rafraichissable vue, String idUtilisateur, String idStr) {
 105 
	public void supprimerStructure(Rafraichissable vueARafraichir, String idUtilisateur, String idStr) {
105 
		StructureAsyncDao structureDao = new StructureAsyncDao();
 106 
		StructureAsyncDao structureDao = new StructureAsyncDao();
106 
		structureDao.supprimer(vue, idUtilisateur, idStr);
 107 
		structureDao.supprimer(vueARafraichir, idUtilisateur, idStr);
107 
	}
 108 
	}
108
109
109 
	public void modifierStructure(Rafraichissable vue, String utilisateurId, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
 110 
	public void modifierStructure(Rafraichissable vueARafraichir, String utilisateurId, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
110 
		StructureAsyncDao structureDao = new StructureAsyncDao();
 111 
		StructureAsyncDao structureDao = new StructureAsyncDao();
111 
		structureDao.modifier(vue, utilisateurId, structureId, structure, conservation, valorisation);
 112 
		structureDao.modifier(vueARafraichir, utilisateurId, structureId, structure, conservation, valorisation);
112 
	}
 113 
	}
113 
 
 114 
 
114 
	//+----------------------------------------------------------------------------------------------------------------+
 115 
	//+----------------------------------------------------------------------------------------------------------------+
115 
	// GESTION de la relation STRUCTURE A PERSONNE
 116 
	// GESTION de la relation STRUCTURE A PERSONNE
116
117
117 
	public void selectionnerStructureAPersonne(Rafraichissable vue, String idUtilisateur, String projetId, String structureId, String roleId) {
 118 
	public void selectionnerStructureAPersonne(Rafraichissable vueARafraichir, String idUtilisateur, String projetId, String structureId, String roleId) {
118 
		// Gestion des données de la table coel_structure_a_personne
 119 
		// Gestion des données de la table coel_structure_a_personne
119 
		if (structureId != null && roleId != null) {
 120 
		if (structureId != null && roleId != null) {
120 
			StructureAPersonneAsyncDao sapDao = new StructureAPersonneAsyncDao();
 121 
			StructureAPersonneAsyncDao sapDao = new StructureAPersonneAsyncDao();
121 
			sapDao.selectionner(vue, idUtilisateur, structureId, roleId);
 122 
			sapDao.selectionner(vueARafraichir, idUtilisateur, structureId, roleId);
122 
		}
 123 
		}
123 
	}
 124 
	}
124
125
125 
	public void modifierStructureAPersonne(Rafraichissable vue, String utilisateurId, StructureAPersonne personnel) {
 126 
	public void modifierStructureAPersonne(Rafraichissable vueARafraichir, String utilisateurId, StructureAPersonne personnel) {
126 
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
 127 
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
127 
		structureAPersonneDao.modifier(vue, utilisateurId, personnel);
 128 
		structureAPersonneDao.modifier(vueARafraichir, utilisateurId, personnel);
128 
	}
 129 
	}
129
130
130 
	public void ajouterStructureAPersonne(Rafraichissable vue, String utilisateurId, String structureId, StructureAPersonne personnel) {
 131 
	public void ajouterStructureAPersonne(Rafraichissable vueARafraichir, String utilisateurId, String structureId, StructureAPersonne personnel) {
131 
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
 132 
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
132 
		structureAPersonneDao.ajouter(vue, utilisateurId, structureId, personnel);
133 
		structureAPersonneDao.ajouter(vueARafraichir, utilisateurId, structureId, personnel);
133 
	}
 134 
	}
134
135
135 
	public void supprimerStructureAPersonne(Rafraichissable vue, String utilisateurId, String personnelId) {
 136 
	public void supprimerStructureAPersonne(Rafraichissable vueARafraichir, String utilisateurId, String personnelId) {
136 
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
 137 
		StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
137 
		structureAPersonneDao.supprimer(vue, utilisateurId, personnelId);
 138 
		structureAPersonneDao.supprimer(vueARafraichir, utilisateurId, personnelId);
138 
	}
 139 
	}
139 
 
 140 
 
140 
	//+----------------------------------------------------------------------------------------------------------------+
 141 
	//+----------------------------------------------------------------------------------------------------------------+
141 
	//												GESTION DES COLLECTIONS
 142 
	//												GESTION DES COLLECTIONS
142 
	//+----------------------------------------------------------------------------------------------------------------+
 143 
	//+----------------------------------------------------------------------------------------------------------------+
143
144
144 
	public void selectionnerCollection(Rafraichissable vueARafraichir, String projetId, String collectionId) {
 145 
	public void selectionnerCollection(Rafraichissable vueARafraichir, String projetId, String collectionId) {
145
- 
 
- 
 
 146 
		CollectionAsyncDao cDao = new CollectionAsyncDao();
- 
 
 147 
		cDao.selectionner(vueARafraichir, projetId, collectionId);
146 
	}
 148 
	}
147
149
148 
	public void ajouterCollection(Rafraichissable vueARafraichir,
 150 
	public void ajouterCollection(Rafraichissable vueARafraichir,
149 
			String utilisateurId, Collection collection) {
 151 
			String utilisateurId, Collection collection) {
150 
		// TODO Auto-generated method stub
 152 
		// TODO Auto-generated method stub
151
153
152 
	}
 154 
	}
153 
 
 155 
 
154 
	public void modifierCollection(Rafraichissable vueARafraichir,
 156 
	public void modifierCollection(Rafraichissable vueARafraichir,
155 
			String utilisateurId, Collection collection) {
 157 
			String utilisateurId, Collection collection) {
156 
		// TODO Auto-generated method stub
 158 
		// TODO Auto-generated method stub
157
159
158 
	}
 160 
	}
159 
 
 161 
 
160 
	public void supprimerCollection(Rafraichissable vueARafraichir,
 162 
	public void supprimerCollection(Rafraichissable vueARafraichir,
161 
			String utilisateurId, String identifiantsCollectionSepareParVirgule) {
 163 
			String utilisateurId, String identifiantsCollectionSepareParVirgule) {
162 
		// TODO Auto-generated method stub
 164 
		// TODO Auto-generated method stub
163
165
164 
	}
 166 
	}
165
167
166 
	//+----------------------------------------------------------------------------------------------------------------+
 168 
	//+----------------------------------------------------------------------------------------------------------------+
167 
	//												GESTION DES PERSONNES
 169 
	//												GESTION DES PERSONNES
168 
	//+----------------------------------------------------------------------------------------------------------------+
 170 
	//+----------------------------------------------------------------------------------------------------------------+
169
171
170 
	public void selectionnerPersonne(Rafraichissable vue, String personneId, String projetId, String nomComplet) {
 172 
	public void selectionnerPersonne(Rafraichissable vueARafraichir, String personneId, String projetId, String nomComplet) {
171 
		PersonneAsyncDao pDao = new PersonneAsyncDao(vue);
 173 
		PersonneAsyncDao pDao = new PersonneAsyncDao(vueARafraichir);
172 
		pDao.selectionner(personneId, projetId, nomComplet);
 174 
		pDao.selectionner(personneId, projetId, nomComplet);
173 
	}
 175 
	}
174 
 
 176 
 
175 
	public void supprimerPersonne(Rafraichissable vue, String idStr) {
 177 
	public void supprimerPersonne(Rafraichissable vueARafraichir, String idStr) {
176 
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vue);
 178 
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vueARafraichir);
177 
		personneDao.supprimer(vue, idStr);
 179 
		personneDao.supprimer(vueARafraichir, idStr);
178
180
179 
	}
 181 
	}
180
182
181 
	public void ajouterPersonne(Rafraichissable vue, Personne personne)	{
 183 
	public void ajouterPersonne(Rafraichissable vue, Personne personne)	{
182 
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vue);
 184 
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vue);
183 
		personneDao.ajouter(vue, personne);
 185 
		personneDao.ajouter(vue, personne);
184 
	}
 186 
	}
185
187
186 
	public void modifierPersonne(Rafraichissable vue, Personne personne)	{
 188 
	public void modifierPersonne(Rafraichissable vueARafraichir, Personne personne)	{
187 
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vue);
 189 
		PersonneAsyncDao personneDao = new PersonneAsyncDao(vueARafraichir);
188 
		personneDao.modifier(vue, personne);
 190 
		personneDao.modifier(vueARafraichir, personne);
189 
	}
 191 
	}
190
192
191 
	//+----------------------------------------------------------------------------------------------------------------+
 193 
	//+----------------------------------------------------------------------------------------------------------------+
192 
	//												GESTION DES PUBLICATIONS
 194 
	//												GESTION DES PUBLICATIONS
193 
	//+----------------------------------------------------------------------------------------------------------------+
 195 
	//+----------------------------------------------------------------------------------------------------------------+
194
196
195 
	public void selectionnerPublications(Rafraichissable vue) {
197 
	public void selectionnerPublications(Rafraichissable vueARafraichir) {
196 
		PublicationAsyncDao lsDao = new PublicationAsyncDao(vue);
 198 
		PublicationAsyncDao lsDao = new PublicationAsyncDao(vueARafraichir);
197 
		lsDao.obtenirListePublication();
 199 
		lsDao.obtenirListePublication();
198 
	}
 200 
	}
199
201
200 
	public void modifierPublication(Rafraichissable vue, String utilisateurId, Publication publi) {
 202 
	public void modifierPublication(Rafraichissable vueRafraichir, String utilisateurId, Publication publi) {
201 
		PublicationAsyncDao pDao = new PublicationAsyncDao(vue);
 203 
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueRafraichir);
202 
		pDao.modifierPublication(utilisateurId, publi);
 204 
		pDao.modifierPublication(utilisateurId, publi);
203 
	}
 205 
	}
204 
 
 206 
 
205 
	public void ajouterPublication(Rafraichissable vue, String utilisateurId, Publication publi) {
 207 
	public void ajouterPublication(Rafraichissable vueARafraichir, String utilisateurId, Publication publi) {
206 
		PublicationAsyncDao pDao = new PublicationAsyncDao(vue);
 208 
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueARafraichir);
207 
		pDao.ajouterPublication(utilisateurId, publi);
 209 
		pDao.ajouterPublication(utilisateurId, publi);
208 
	}
 210 
	}
209 
 
 211 
 
210 
	public void supprimerPublication(Rafraichissable vue, String utilisateurId, List<Publication> publicationListe) {
 212 
	public void supprimerPublication(Rafraichissable vueARafraichir, String utilisateurId, List<Publication> publicationListe) {
211 
		String idPubs = "";
 213 
		String idPubs = "";
212 
		for(Iterator<Publication> it = publicationListe.iterator(); it.hasNext();) {
 214 
		for(Iterator<Publication> it = publicationListe.iterator(); it.hasNext();) {
213 
			Publication pub = it.next();
 215 
			Publication pub = it.next();
214 
			idPubs += pub.getId();
 216 
			idPubs += pub.getId();
215 
			if(it.hasNext()) {
 217 
			if(it.hasNext()) {
216 
				idPubs += ",";
 218 
				idPubs += ",";
217 
			}
 219 
			}
218 
		}
 220 
		}
219 
		PublicationAsyncDao pDao = new PublicationAsyncDao(vue);
 221 
		PublicationAsyncDao pDao = new PublicationAsyncDao(vueARafraichir);
220 
		pDao.supprimerPublication(utilisateurId, idPubs);
222 
		pDao.supprimerPublication(utilisateurId, idPubs);
221 
	}
 223 
	}
222 
 
 224 
 
223 
}
 225 
}