Subversion Repositories eFlore/Applications.cel

Rev

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

Rev 2042 Rev 2062
1 
package org.tela_botanica.client.observation;
 1 
package org.tela_botanica.client.observation;
2 
 
 2 
 
3 
 
 3 
 
4 
//TODO : normaliser les noms de methodes (obtenir, ajouter ...)
 4 
//TODO : normaliser les noms de methodes (obtenir, ajouter ...)
5 
 
 5 
 
6 
import java.util.HashMap;
 6 
import java.util.HashMap;
7 
import org.tela_botanica.client.interfaces.Rafraichissable;
 7 
import org.tela_botanica.client.interfaces.Rafraichissable;
8 
import org.tela_botanica.client.modeles.dao.ExportObservationsDAO;
 8 
import org.tela_botanica.client.modeles.dao.ExportObservationsDAO;
9 
import org.tela_botanica.client.modeles.dao.ImageGeneriqueVueAsynchroneDAO;
 9 
import org.tela_botanica.client.modeles.dao.ImageGeneriqueVueAsynchroneDAO;
10 
import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO;
 10 
import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO;
11 
import org.tela_botanica.client.modeles.dao.ImportObservationAsynchroneDAO;
 11 
import org.tela_botanica.client.modeles.dao.ImportObservationAsynchroneDAO;
12 
import org.tela_botanica.client.modeles.dao.InformationCommuneDAO;
 12 
import org.tela_botanica.client.modeles.dao.InformationCommuneDAO;
13 
import org.tela_botanica.client.modeles.dao.LiaisonMotsClesObsAsynchroneDAO;
 13 
import org.tela_botanica.client.modeles.dao.LiaisonMotsClesObsAsynchroneDAO;
14 
import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;
 14 
import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;
15 
import org.tela_botanica.client.modeles.dao.ListeDateObservationAsynchroneDAO;
 15 
import org.tela_botanica.client.modeles.dao.ListeDateObservationAsynchroneDAO;
16 
import org.tela_botanica.client.modeles.dao.ListeEntiteGeographiqueObservationAsynchroneDAO;
 16 
import org.tela_botanica.client.modeles.dao.ListeEntiteGeographiqueObservationAsynchroneDAO;
17 
import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;
 17 
import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;
18 
import org.tela_botanica.client.modeles.dao.ListeReferentielCommuneAsynchroneDAO;
 18 
import org.tela_botanica.client.modeles.dao.ListeReferentielCommuneAsynchroneDAO;
19 
import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO;
 19 
import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO;
20 
import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO;
 20 
import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO;
21 
import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;
 21 
import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;
22 
import org.tela_botanica.client.modeles.dao.NomRetenuAsynchroneDAO;
 22 
import org.tela_botanica.client.modeles.dao.NomRetenuAsynchroneDAO;
23 
import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;
 23 
import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;
24 
import org.tela_botanica.client.modeles.dao.ObservationAsynchroneDAO;
 24 
import org.tela_botanica.client.modeles.dao.ObservationAsynchroneDAO;
25 
import org.tela_botanica.client.modeles.dao.TransmissionObservationAsynchroneDAO;
 25 
import org.tela_botanica.client.modeles.dao.TransmissionObservationAsynchroneDAO;
26 
import org.tela_botanica.client.modeles.objets.Configuration;
 26 
import org.tela_botanica.client.modeles.objets.Configuration;
27 
import org.tela_botanica.client.modeles.objets.ListeObservation;
 27 
import org.tela_botanica.client.modeles.objets.ListeObservation;
28 
import org.tela_botanica.client.modeles.objets.Observation;
 28 
import org.tela_botanica.client.modeles.objets.Observation;
29 
import org.tela_botanica.client.modeles.objets.Utilisateur;
 29 
import org.tela_botanica.client.modeles.objets.Utilisateur;
30 
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
 30 
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
31 
import org.tela_botanica.client.util.MotsClesUtilitaire;
 31 
import org.tela_botanica.client.util.MotsClesUtilitaire;
32 
 
 32 
 
33 
import com.google.gwt.json.client.JSONArray;
 33 
import com.google.gwt.json.client.JSONArray;
34 
import com.google.gwt.json.client.JSONObject;
 34 
import com.google.gwt.json.client.JSONObject;
35 
import com.google.gwt.user.client.Window;
 35 
import com.google.gwt.user.client.Window;
36 
import com.gwtext.client.data.Node;
 36 
import com.gwtext.client.data.Node;
37 
import com.gwtext.client.data.Tree;
 37 
import com.gwtext.client.data.Tree;
38 
import com.gwtext.client.widgets.tree.TreeNode;
 38 
import com.gwtext.client.widgets.tree.TreeNode;
39 
 
 39 
 
40 
 
 40 
 
41 
public class ObservationModele implements Rafraichissable {
 41 
public class ObservationModele implements Rafraichissable {
42 
 
 42 
 
43 
	/**
 43 
	/**
44 
	 * Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)
 44 
	 * Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)
45 
	 */
 45 
	 */
46 
	private static boolean estInstancie = false ;
 46 
	private static boolean estInstancie = false ;
47
47
48 
	private static ObservationModele thisModele = null ;
 48 
	private static ObservationModele thisModele = null ;
49
49
50 
	/**
 50 
	/**
51 
	 * La configuration en cours
 51 
	 * La configuration en cours
52 
	 */
 52 
	 */
53 
	private Configuration config = null;
 53 
	private Configuration config = null;
54 
 
 54 
 
55 
	/**
 55 
	/**
56 
	 * Le médiateur associé au modèle
 56 
	 * Le médiateur associé au modèle
57 
	 */
 57 
	 */
58
58
59 
	private ObservationMediateur observationMediateur = null ;
 59 
	private ObservationMediateur observationMediateur = null ;
60
60
61 
	/**
 61 
	/**
62 
	 * La liste des mots clés en cours
62 
	 * La liste des mots clés en cours
63 
	 */
 63 
	 */
64 
	private HashMap<String, String> motsCles = new HashMap<String, String>(0);
 64 
	private HashMap<String, String> motsCles = new HashMap<String, String>(0);
65
65
66 
	private Tree arbreMotsCles = new Tree() ;
 66 
	private Tree arbreMotsCles = new Tree() ;
67
67
68 
	/**
 68 
	/**
69 
	 * La liste des observations affichées en cours (verifier utilité)
 69 
	 * La liste des observations affichées en cours (verifier utilité)
70 
	 */
 70 
	 */
71
71
72 
	private ListeObservation cacheObservation = new ListeObservation(0) ;
 72 
	private ListeObservation cacheObservation = new ListeObservation(0) ;
73
73
74 
	/**
 74 
	/**
75 
	 * DAO dont le resultat peut etre mis en cache
75 
	 * DAO dont le resultat peut etre mis en cache
76 
	 *
76 
	 *
77 
	 */
 77 
	 */
78
78
79 
	private ListeReferentielNomAsynchroneDAO nomDAO=null;
 79 
	private ListeReferentielNomAsynchroneDAO nomDAO=null;
80 
	private ListeReferentielCommuneAsynchroneDAO refDAO=null;
 80 
	private ListeReferentielCommuneAsynchroneDAO refDAO=null;
81 
	private ListeReferentielPersoAsynchroneDAO refPersoDAO=null;
 81 
	private ListeReferentielPersoAsynchroneDAO refPersoDAO=null;
82 
 
 82 
 
83 
	/**
 83 
	/**
84 
	 * Retourne une instance de manière unique
 84 
	 * Retourne une instance de manière unique
85 
	 * @param im le médiateur à associer
 85 
	 * @param im le médiateur à associer
86 
	 * @return l'instance du modèle
 86 
	 * @return l'instance du modèle
87 
	 */
 87 
	 */
88
88
89 
	static ObservationModele Instance(ObservationMediateur observationMediateur)
 89 
	static ObservationModele Instance(ObservationMediateur observationMediateur)
90 
	{
 90 
	{
91 
		// si le modèle n'est pas encore instancié
 91 
		// si le modèle n'est pas encore instancié
92 
		if(!estInstancie)
 92 
		if(!estInstancie)
93 
		{
 93 
		{
94 
			// on en crée un nouveau
 94 
			// on en crée un nouveau
95 
			estInstancie = true ;
 95 
			estInstancie = true ;
96 
			thisModele = new ObservationModele(observationMediateur);
 96 
			thisModele = new ObservationModele(observationMediateur);
97 
		}
 97 
		}
98 
		return thisModele ;
 98 
		return thisModele ;
99 
	}
 99 
	}
100 
 
 100 
 
101
101
102
102
103 
	private ObservationModele(ObservationMediateur observationMediateur) {
 103 
	private ObservationModele(ObservationMediateur observationMediateur) {
104
104
105 
		this.observationMediateur=observationMediateur;
 105 
		this.observationMediateur=observationMediateur;
106
106
107 
		config = new Configuration();
 107 
		config = new Configuration();
108 
 
 108 
 
109
109
110 
	}
 110 
	}
111 
 
 111 
 
112 
	/**
 112 
	/**
113 
	 * Appelle le DAO asynchrone pour obtenir le nombre d'observation
 113 
	 * Appelle le DAO asynchrone pour obtenir le nombre d'observation
114 
	 * @param r le rafraichissable auxquel on enverra les données
 114 
	 * @param r le rafraichissable auxquel on enverra les données
115 
	 * @param filtrage
115 
	 * @param filtrage
116 
	 * @param taillePage
116 
	 * @param taillePage
117 
	 */
 117 
	 */
118 
	public void obtenirNombreObservation(Rafraichissable r) {
118 
	public void obtenirNombreObservation(Rafraichissable r) {
119
119
120 
		String[][] criteres = {{"",""}} ;
120 
		String[][] criteres = {{"",""}} ;
121 
		 	criteres = observationMediateur.renvoyerFiltres() ;
121 
		 	criteres = observationMediateur.renvoyerFiltres() ;
122 
			// on rassemble les critères
 122 
			// on rassemble les critères
123 
			// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
 123 
			// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
124 
			NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this) ;
 124 
			NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this) ;
125 
			noaDAO.obtenirNombreObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres) ;
 125 
			noaDAO.obtenirNombreObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres) ;
126
126
127 
	}
 127 
	}
128
128
129
129
130 
	public void obtenirListeObservation(Rafraichissable r) {
 130 
	public void obtenirListeObservation(Rafraichissable r) {
131 
		obtenirListeObservation(r,observationMediateur.getTaillePage(),observationMediateur.getPageEnCours());
 131 
		obtenirListeObservation(r,observationMediateur.getTaillePage(),observationMediateur.getPageEnCours());
132 
	}
 132 
	}
133
133
134 
	/**
 134 
	/**
135 
	 * Appelle le DAO asynchrone pour obtenir la liste des images
 135 
	 * Appelle le DAO asynchrone pour obtenir la liste des images
136 
	 * @param r le rafraichissable auxquel on enverra les données
 136 
	 * @param r le rafraichissable auxquel on enverra les données
137 
	 * @param taillePage
137 
	 * @param taillePage
138 
	 */
 138 
	 */
139 
	public void obtenirListeObservation(Rafraichissable r, int taillePage, int pageEncours) {
139 
	public void obtenirListeObservation(Rafraichissable r, int taillePage, int pageEncours) {
140
140
141
141
142 
		 	String[][] criteres = {{"",""}} ;
 142 
		 	String[][] criteres = {{"",""}} ;
143 
			criteres = observationMediateur.renvoyerFiltres() ;
143 
			criteres = observationMediateur.renvoyerFiltres() ;
144 
			// on rassemble les critères
 144 
			// on rassemble les critères
145
145
146
146
147 
			// ensuite on demande la page correspondante avec les mêmes critères
 147 
			// ensuite on demande la page correspondante avec les mêmes critères
148 
			String[][] criteres2 = new String[criteres.length+4][2] ;
 148 
			String[][] criteres2 = new String[criteres.length+4][2] ;
149
149
150 
			criteres2[0][0] = "limite" ;
 150 
			criteres2[0][0] = "limite" ;
151 
			criteres2[0][1] = ""+taillePage ;
 151 
			criteres2[0][1] = ""+taillePage ;
152 
			criteres2[1][0] = "numero_page" ;
 152 
			criteres2[1][0] = "numero_page" ;
153 
			criteres2[1][1] = ""+pageEncours ;
 153 
			criteres2[1][1] = ""+pageEncours ;
154 
			criteres2[2][0] = "tri" ;
 154 
			criteres2[2][0] = "tri" ;
155 
			criteres2[2][1] = ""+observationMediateur.renvoyerTri();
 155 
			criteres2[2][1] = ""+observationMediateur.renvoyerTri();
156 
			criteres2[3][0] = "tri_dir";
 156 
			criteres2[3][0] = "tri_dir";
157 
			criteres2[3][1] = ""+observationMediateur.renvoyerDirectionTri() ;
 157 
			criteres2[3][1] = ""+observationMediateur.renvoyerDirectionTri() ;
158
158
159 
			for(int i = 0 ; i < criteres.length ; i++)
 159 
			for(int i = 0 ; i < criteres.length ; i++)
160 
			{
 160 
			{
161 
				criteres2[i+4][0] = criteres[i][0] ;
161 
				criteres2[i+4][0] = criteres[i][0] ;
162 
				criteres2[i+4][1] = criteres[i][1] ;
162 
				criteres2[i+4][1] = criteres[i][1] ;
163 
			}
 163 
			}
164
164
165 
			// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
 165 
			// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
166 
			ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
 166 
			ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
167 
			loaDAO.obtenirListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres2);
167 
			loaDAO.obtenirListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres2);
168 
	}
 168 
	}
169
169
170 
 
 170 
 
171 
	/**
 171 
	/**
172 
	 * Obtenir une liste de commune
172 
	 * Obtenir une liste de commune
173 
	 * @param r
 173 
	 * @param r
174 
	 * @param critere
 174 
	 * @param critere
175 
	 */
 175 
	 */
176
176
177 
	public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
 177 
	public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
178
178
179 
		if (refDAO==null) {
 179 
		if (refDAO==null) {
180 
			refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
 180 
			refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
181 
		}
 181 
		}
182 
		refDAO.obtenirListeDonnees(r, critere);
 182 
		refDAO.obtenirListeDonnees(r, critere);
183
183
184 
	}
 184 
	}
185
185
186 
	/**
 186 
	/**
187 
	 * Obtenir une liste de commune
187 
	 * Obtenir une liste de commune
188 
	 * @param r
 188 
	 * @param r
189 
	 * @param critere
 189 
	 * @param critere
190 
	 */
 190 
	 */
191 
	public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) {
 191 
	public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) {
192
192
193 
		if (refPersoDAO==null) {
 193 
		if (refPersoDAO==null) {
194 
			refPersoDAO=new ListeReferentielPersoAsynchroneDAO(this);
 194 
			refPersoDAO=new ListeReferentielPersoAsynchroneDAO(this);
195 
		}
 195 
		}
196
196
197 
		refPersoDAO.setRefDemande(referentiel);
 197 
		refPersoDAO.setRefDemande(referentiel);
198 
		refPersoDAO.obtenirListeDonnees(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), critere);
 198 
		refPersoDAO.obtenirListeDonnees(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), critere);
199
199
200 
	}
 200 
	}
201
201
202 
	/**
 202 
	/**
203 
	 * Obtenir une liste de nom scientifique de plante
 203 
	 * Obtenir une liste de nom scientifique de plante
204 
	 * @param r
 204 
	 * @param r
205 
	 * @param critere
 205 
	 * @param critere
206 
	 */
206 
	 */
207 
	public void obtenirListeReferentielNom(Rafraichissable r, String referentiel, String critere) {
 207 
	public void obtenirListeReferentielNom(Rafraichissable r, String referentiel, String critere) {
208
208
209 
		if (nomDAO==null) {
 209 
		if (nomDAO==null) {
210 
			nomDAO=new ListeReferentielNomAsynchroneDAO(this);
 210 
			nomDAO=new ListeReferentielNomAsynchroneDAO(this);
211 
		}
 211 
		}
212 
		nomDAO.obtenirListeDonnees(r, referentiel, critere);
 212 
		nomDAO.obtenirListeDonnees(r, referentiel, critere);
213
213
214 
	}
 214 
	}
215
215
216
216
217 
	/**
 217 
	/**
218 
	 *
218 
	 *
219 
	 * Lance la creation d'une observation
219 
	 * Lance la creation d'une observation
220 
	 * @param r : la vue demandeuse de donnee
 220 
	 * @param r : la vue demandeuse de donnee
221 
	 * @param critere : les criteres de selection
 221 
	 * @param critere : les criteres de selection
222 
	 */
 222 
	 */
223
223
224 
	public void ajouterObservation(Rafraichissable r, Observation obs) {
 224 
	public void ajouterObservation(Rafraichissable r, Observation obs) {
225
225
226 
		ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
 226 
		ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
227 
		obsDAO.ajouter(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
 227 
		obsDAO.ajouter(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
228
228
229 
	}
 229 
	}
230 
 
 230 
 
231 
	/**
 231 
	/**
232 
	 *
232 
	 *
233 
	 * Lance la creation d'une observation
233 
	 * Lance la creation d'une observation
234 
	 * @param r : la vue demandeuse de donnee
 234 
	 * @param r : la vue demandeuse de donnee
235 
	 * @param critere : les criteres de selection
 235 
	 * @param critere : les criteres de selection
236 
	 */
 236 
	 */
237 
	public void modifierObservation(Rafraichissable r, Observation obs) {
 237 
	public void modifierObservation(Rafraichissable r, Observation obs) {
238
238
239 
		ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
 239 
		ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
240 
		obsDAO.modifier(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
 240 
		obsDAO.modifier(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
241
241
242 
	}
 242 
	}
243
243
244 
 
 244 
 
245 
 
 245 
 
246 
	public void modifierObservationEnMasse(
 246 
	public void modifierObservationEnMasse(
247 
			Rafraichissable r, Observation obs) {
 247 
			Rafraichissable r, Observation obs) {
248 
		ListeObservationAsynchroneDAO liObsDAO=new ListeObservationAsynchroneDAO(this);
 248 
		ListeObservationAsynchroneDAO liObsDAO=new ListeObservationAsynchroneDAO(this);
249 
		liObsDAO.modifierEnMasse(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
 249 
		liObsDAO.modifierEnMasse(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
250
250
251 
	}
 251 
	}
252 
 
 252 
 
253 
 
 253 
 
254
254
255 
	public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
 255 
	public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
256
256
257 
		ObservationAsynchroneDAO obsDao = new ObservationAsynchroneDAO(this) ;
 257 
		ObservationAsynchroneDAO obsDao = new ObservationAsynchroneDAO(this) ;
258 
		obsDao.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(),numeroOrdre) ;
 258 
		obsDao.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(),numeroOrdre) ;
259
259
260
260
261 
	}
 261 
	}
262
262
263
263
264 
 
 264 
 
265 
 
 265 
 
266 
	/**
 266 
	/**
267 
	 * Accesseur pour la configuration en cours d'utilisation
 267 
	 * Accesseur pour la configuration en cours d'utilisation
268 
	 *
268 
	 *
269 
	 * @return la configuration
 269 
	 * @return la configuration
270 
	 */
 270 
	 */
271 
	public Configuration getConfig() {
 271 
	public Configuration getConfig() {
272 
 
 272 
 
273 
		return config;
 273 
		return config;
274 
	}
 274 
	}
275 
 
 275 
 
276
276
277 
	/**
 277 
	/**
278 
	 * Obtenir des informations de repartition relative a un numero nomenclatural
 278 
	 * Obtenir des informations de repartition relative a un numero nomenclatural
279 
	 * @param r
 279 
	 * @param r
280 
	 * @param numeroNomenclaturalSaisiObservation
 280 
	 * @param numeroNomenclaturalSaisiObservation
281 
	 */
 281 
	 */
282 
 
 282 
 
283 
 
 283 
 
284 
	public void obtenirImageInformationRepartition(Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
 284 
	public void obtenirImageInformationRepartition(Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
285
285
286 
		ImageInformationRepartitionAsynchroneDAO repDAO= new ImageInformationRepartitionAsynchroneDAO(this);
 286 
		ImageInformationRepartitionAsynchroneDAO repDAO= new ImageInformationRepartitionAsynchroneDAO(this);
287 
		repDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation);
 287 
		repDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation);
288
288
289
289
290 
	}
 290 
	}
291 
 
 291 
 
292 
	/**
 292 
	/**
293 
	 * Obtenir une image generique associee a un numero nomenclatural
 293 
	 * Obtenir une image generique associee a un numero nomenclatural
294 
	 * @param r
 294 
	 * @param r
295 
	 * @param numeroNomenclaturalSaisiObservation
 295 
	 * @param numeroNomenclaturalSaisiObservation
296 
	 */
 296 
	 */
297 
 
 297 
 
298 
	public void obtenirImageGenerique( Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
 298 
	public void obtenirImageGenerique( Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
299
299
300 
		ImageGeneriqueVueAsynchroneDAO imgDAO= new ImageGeneriqueVueAsynchroneDAO(this);
 300 
		ImageGeneriqueVueAsynchroneDAO imgDAO= new ImageGeneriqueVueAsynchroneDAO(this);
301 
		imgDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation);
 301 
		imgDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation);
302
302
303
303
304 
	}
 304 
	}
305 
 
 305 
 
306 
 
 306 
 
307 
	/**
 307 
	/**
308 
	 * Obtenir la liste de l'ensemble des entites geographiques associes aux observation d'un utilisateur
308 
	 * Obtenir la liste de l'ensemble des entites geographiques associes aux observation d'un utilisateur
309 
	 * @param r
 309 
	 * @param r
310 
	 */
 310 
	 */
311 
 
 311 
 
312 
	public void obtenirListeEntiteGeographique(Rafraichissable r) {
 312 
	public void obtenirListeEntiteGeographique(Rafraichissable r) {
313 
 
 313 
 
314 
	    ListeEntiteGeographiqueObservationAsynchroneDAO entDAO = new ListeEntiteGeographiqueObservationAsynchroneDAO(this);
 314 
	    ListeEntiteGeographiqueObservationAsynchroneDAO entDAO = new ListeEntiteGeographiqueObservationAsynchroneDAO(this);
315 
	    entDAO.obtenirListeEntitesGeographiques(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
 315 
	    entDAO.obtenirListeEntitesGeographiques(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
316 
 
 316 
 
317 
	}
 317 
	}
318 
 
 318 
 
319 
 
 319 
 
320 
 
 320 
 
321 
	public void obtenirDatesObservation(
 321 
	public void obtenirDatesObservation(
322 
			Rafraichissable r) {
 322 
			Rafraichissable r) {
323 
	    ListeDateObservationAsynchroneDAO ldoDAO = new ListeDateObservationAsynchroneDAO(this);
 323 
	    ListeDateObservationAsynchroneDAO ldoDAO = new ListeDateObservationAsynchroneDAO(this);
324 
	    ldoDAO.obtenirListeDate(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
 324 
	    ldoDAO.obtenirListeDate(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
325
325
326 
	}
 326 
	}
327 
 
 327 
 
328 
 
 328 
 
329 
 
 329 
 
330 
	public void obtenirLiaisonImage(Rafraichissable r,
 330 
	public void obtenirLiaisonImage(Rafraichissable r,
331 
			String idObservation) {
 331 
			String idObservation) {
332
332
333 
		LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ;
 333 
		LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ;
334 
		liaDAO.obtenirLiaisonsObservationsImages(r, idObservation,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()) ;
 334 
		liaDAO.obtenirLiaisonsObservationsImages(r, idObservation,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()) ;
335
335
336 
	}
 336 
	}
337 
 
 337 
 
338 
 
 338 
 
339 
 
 339 
 
340 
	public void exporterObservations(String format, String groupes) {
 340 
	public void exporterObservations(String format, String groupes) {
341 
		String[][] criteres = {{"",""}} ;
341 
		String[][] criteres = {{"",""}} ;
342 
	 	criteres = observationMediateur.renvoyerFiltres();
 342 
	 	criteres = observationMediateur.renvoyerFiltres();
343 
		// on rassemble les critères
 343 
		// on rassemble les critères
344 
		// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
344 
		// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
345 
		ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
 345 
		ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
346 
		exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres, format, groupes) ;
 346 
		exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres, format, groupes) ;
347 
	}
 347 
	}
348 
 
 348 
 
349 
	public void exporterObservationsPDF(String[] ordres) {
 349 
	public void exporterObservationsPDF(String[] ordres) {
350 
		String[][] criteres = {{"",""}} ;
350 
		String[][] criteres = {{"",""}} ;
351 
	 	criteres = observationMediateur.renvoyerFiltres();
 351 
	 	criteres = observationMediateur.renvoyerFiltres();
352 
		String ids = "";
 352 
		String ids = "";
353 
		for (int j = 0; j < ordres.length; j++) {
 353 
		for (int j = 0; j < ordres.length; j++) {
354 
			ids += getIdPourOrdreObs(ordres[j]) + ",";
 354 
			ids += getIdPourOrdreObs(ordres[j]) + ",";
355 
		}
 355 
		}
356 
 
 356 
 
357 
		String[] fmt = {"obsids", ids};
 357 
		String[] fmt = {"obsids", ids};
358 
		String[][] tous_criteres = new String[criteres.length + 1][];
 358 
		String[][] tous_criteres = new String[criteres.length + 1][];
359 
		System.arraycopy(criteres, 0, tous_criteres, 0, criteres.length);
 359 
		System.arraycopy(criteres, 0, tous_criteres, 0, criteres.length);
360 
		tous_criteres[tous_criteres.length - 1] = fmt;
 360 
		tous_criteres[tous_criteres.length - 1] = fmt;
361 
 
 361 
 
362 
		ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
 362 
		ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
363 
		exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), tous_criteres, "pdf", "standard") ;
 363 
		exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), tous_criteres, "pdf", "standard") ;
364 
	}
 364 
	}
365 
 
 365 
 
366 
 
 366 
 
367 
 
 367 
 
368 
	public void supprimerLiaisonImages(String idImg, String idObs) {
 368 
	public void supprimerLiaisonImages(String idImg, String idObs) {
369
369
370 
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
 370 
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
371 
		lienDAO.supprimerLienImageObservation(idImg, idObs) ;
371 
		lienDAO.supprimerLienImageObservation(idImg, idObs) ;
372
372
373 
	}
 373 
	}
374 
 
 374 
 
375 
	public void supprimerListeObservation(Rafraichissable r,
 375 
	public void supprimerListeObservation(Rafraichissable r,
376 
			String numObs) {
 376 
			String numObs) {
377 
		ListeObservationAsynchroneDAO lioaDAO = new ListeObservationAsynchroneDAO(this);
 377 
		ListeObservationAsynchroneDAO lioaDAO = new ListeObservationAsynchroneDAO(this);
378 
		lioaDAO.supprimerListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObs);
 378 
		lioaDAO.supprimerListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObs);
379
379
380 
	}
 380 
	}
381 
 
 381 
 
382 
	public void transmettreListeObservation(
 382 
	public void transmettreListeObservation(
383 
			Rafraichissable r, String numObsapl, boolean publier) {
 383 
			Rafraichissable r, String numObsapl, boolean publier) {
384 
		TransmissionObservationAsynchroneDAO toaDAO = new TransmissionObservationAsynchroneDAO(this);
 384 
		TransmissionObservationAsynchroneDAO toaDAO = new TransmissionObservationAsynchroneDAO(this);
385 
		toaDAO.transmettreObservations(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObsapl, publier);
 385 
		toaDAO.transmettreObservations(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObsapl, publier);
386
386
387 
	}
 387 
	}
388 
 
 388 
 
389 
	public void analyserHistorique(Rafraichissable r,String anum) {
 389 
	public void analyserHistorique(Rafraichissable r,String anum) {
390
390
391 
		NomRetenuAsynchroneDAO nraDAO = new NomRetenuAsynchroneDAO(this);
 391 
		NomRetenuAsynchroneDAO nraDAO = new NomRetenuAsynchroneDAO(this);
392 
		nraDAO.obtenirNomRetenu(r, anum);
 392 
		nraDAO.obtenirNomRetenu(r, anum);
393
393
394 
	}
 394 
	}
395 
 
 395 
 
396 
 
 396 
 
397 
 
 397 
 
398 
	public void importerObservations() {
 398 
	public void importerObservations() {
399 
		ImportObservationAsynchroneDAO ioDAO = new ImportObservationAsynchroneDAO(this);
 399 
		ImportObservationAsynchroneDAO ioDAO = new ImportObservationAsynchroneDAO(this);
400 
		ioDAO.importerObservations();
 400 
		ioDAO.importerObservations();
401
401
402 
	}
 402 
	}
403 
 
 403 
 
404 
 
 404 
 
405 
 
 405 
 
406 
	public void obtenirArbreMotsCles(Rafraichissable r) {
 406 
	public void obtenirArbreMotsCles(Rafraichissable r) {
407
407
408 
		MotsClesAsynchroneDAO mcoDAO = new MotsClesAsynchroneDAO("obs");
 408 
		MotsClesAsynchroneDAO mcoDAO = new MotsClesAsynchroneDAO("obs");
409 
		mcoDAO.obtenirListeMotsCles(this);
 409 
		mcoDAO.obtenirListeMotsCles(this);
410
410
411 
	}
 411 
	}
412 
 
 412 
 
413 
	@Override
 413 
	@Override
414 
	public void rafraichir(Object nouvelleDonnees,
 414 
	public void rafraichir(Object nouvelleDonnees,
415 
			boolean repandreRaffraichissement) {
415 
			boolean repandreRaffraichissement) {
416 
		if(nouvelleDonnees instanceof JSONArray) {
 416 
		if(nouvelleDonnees instanceof JSONArray) {
417
417
418 
			JSONArray donneesArbre = (JSONArray)nouvelleDonnees;
 418 
			JSONArray donneesArbre = (JSONArray)nouvelleDonnees;
419 
			Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre("Projets", "racine_obs", donneesArbre);
 419 
			Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre("Projets", "racine_obs", donneesArbre, false);
420
420
421 
			arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
 421 
			arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
422 
			motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
 422 
			motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
423
423
424 
			// enfin on met à jour l'arbre des mots clés contenu dans le modèle
 424 
			// enfin on met à jour l'arbre des mots clés contenu dans le modèle
425 
			//rafraichirArbreMotsCles(arbreMotsCles);
 425 
			//rafraichirArbreMotsCles(arbreMotsCles);
426 
			// et on notifie le médiateur de la mise à jour en lui passant une
 426 
			// et on notifie le médiateur de la mise à jour en lui passant une
427 
			// copie des données
 427 
			// copie des données
428 
			observationMediateur.rafraichirArbreMotsCles(arbreMotsCles);
 428 
			observationMediateur.rafraichirArbreMotsCles(arbreMotsCles);
429 
		}
 429 
		}
430
430
431 
		if(nouvelleDonnees instanceof Observation) {
 431 
		if(nouvelleDonnees instanceof Observation) {
432 
			observationMediateur.obtenirNombreObservation();
 432 
			observationMediateur.obtenirNombreObservation();
433 
		}
 433 
		}
434
434
435 
	}
 435 
	}
436 
 
 436 
 
437 
	/**
 437 
	/**
438 
	 * Met à jour l'arbre des mots clés à partir d'un objet
 438 
	 * Met à jour l'arbre des mots clés à partir d'un objet
439 
	 *
439 
	 *
440 
	 * @param o
 440 
	 * @param o
441 
	 *            le nouvel arbre de mots clés
 441 
	 *            le nouvel arbre de mots clés
442 
	 */
 442 
	 */
443 
	public void rafraichirArbreMotsCles(Object o) {
 443 
	public void rafraichirArbreMotsCles(Object o) {
444 
		arbreMotsCles = (com.gwtext.client.data.Tree) o;
 444 
		arbreMotsCles = (com.gwtext.client.data.Tree) o;
445 
	}
 445 
	}
446 
 
 446 
 
447 
	/**
 447 
	/**
448 
	 * Met à jour la table de correspondance mots clés / ids à partir d'un objet
 448 
	 * Met à jour la table de correspondance mots clés / ids à partir d'un objet
449 
	 *
449 
	 *
450 
	 * @param o
 450 
	 * @param o
451 
	 *            la nouvelle table des mots clés
 451 
	 *            la nouvelle table des mots clés
452 
	 */
 452 
	 */
453 
	@SuppressWarnings("unchecked")
 453 
	@SuppressWarnings("unchecked")
454 
	public void rafraichirMotsCles(Object o) {
 454 
	public void rafraichirMotsCles(Object o) {
455 
		if (o instanceof HashMap) {
 455 
		if (o instanceof HashMap) {
456 
			motsCles = (HashMap<String, String>) o;
 456 
			motsCles = (HashMap<String, String>) o;
457 
		}
 457 
		}
458 
	}
 458 
	}
459
459
460 
	/**
 460 
	/**
461 
	 * Va chercher les mots clés associés à une image dans la liste des images
 461 
	 * Va chercher les mots clés associés à une image dans la liste des images
462 
	 * chargée dans le modèle
 462 
	 * chargée dans le modèle
463 
	 *
463 
	 *
464 
	 * @param r
 464 
	 * @param r
465 
	 *            le rafraichissable auquel on enverra les informations
 465 
	 *            le rafraichissable auquel on enverra les informations
466 
	 * @param id
 466 
	 * @param id
467 
	 *            l'identifiant de l'image
 467 
	 *            l'identifiant de l'image
468 
	 */
 468 
	 */
469 
	public void obtenirMotsClesId(Rafraichissable r, String id) {
 469 
	public void obtenirMotsClesId(Rafraichissable r, String id) {
470 
		Observation o = cacheObservation.get(id);
 470 
		Observation o = cacheObservation.get(id);
471 
		String motsClesId = o.getMotsCles();
 471 
		String motsClesId = o.getMotsCles();
472 
		String[] motsClesIdTab = motsClesId.split(",");
 472 
		String[] motsClesIdTab = motsClesId.split(",");
473 
		r.rafraichir(motsClesIdTab, false);
 473 
		r.rafraichir(motsClesIdTab, false);
474 
	}
 474 
	}
475
475
476 
	/**
 476 
	/**
477 
	 * Met à jour les mots clés associés à une obs et appelle le DAO pour
 477 
	 * Met à jour les mots clés associés à une obs et appelle le DAO pour
478 
	 * synchroniser la base de données
 478 
	 * synchroniser la base de données
479 
	 *
479 
	 *
480 
	 * @param ids
 480 
	 * @param ids
481 
	 *            les identifiants des observations selectionnées
 481 
	 *            les identifiants des observations selectionnées
482 
	 * @param motsClesEnCours
 482 
	 * @param motsClesEnCours
483 
	 *            les mots clés à appliquer aux observations
 483 
	 *            les mots clés à appliquer aux observations
484 
	 */
 484 
	 */
485 
	public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) {
 485 
	public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) {
486
486
487 
		String motsCles = "";
 487 
		String motsCles = "";
488 
		String obsAlier = "";
 488 
		String obsAlier = "";
489 
		int nbObs = 0;
 489 
		int nbObs = 0;
490
490
491 
		for (int i = 0; i < idsObsALier.length; i++) {
 491 
		for (int i = 0; i < idsObsALier.length; i++) {
492
492
493 
			if (cacheObservation.containsKey(idsObsALier[i])) {
 493 
			if (cacheObservation.containsKey(idsObsALier[i])) {
494
494
495 
				if(!motsClesEnCours.endsWith(";") && !motsClesEnCours.startsWith(";")) {
 495 
				if(!motsClesEnCours.endsWith(";") && !motsClesEnCours.startsWith(";")) {
496 
					motsCles += ";";
 496 
					motsCles += ";";
497 
				}
 497 
				}
498
498
499 
				motsCles += motsClesEnCours;
 499 
				motsCles += motsClesEnCours;
500
500
501 
				nbObs++;
 501 
				nbObs++;
502
502
503 
				Observation m = cacheObservation.get(idsObsALier[i]);
 503 
				Observation m = cacheObservation.get(idsObsALier[i]);
504 
				obsAlier += ","+m.getId();
 504 
				obsAlier += ","+m.getId();
505
505
506 
				if(m.getMotsCles() != null && !m.getMotsCles().endsWith(";") && !motsCles.startsWith(";")) {
 506 
				if(m.getMotsCles() != null && !m.getMotsCles().endsWith(";") && !motsCles.startsWith(";")) {
507 
					motsCles += ";";
 507 
					motsCles += ";";
508 
				}
 508 
				}
509
509
510 
				m.setMotsCles(m.getMotsCles()+motsCles);
 510 
				m.setMotsCles(m.getMotsCles()+motsCles);
511
511
512 
				cacheObservation.put(m.getNumeroOrdre(), m);
 512 
				cacheObservation.put(m.getNumeroOrdre(), m);
513 
			}
 513 
			}
514 
		}
 514 
		}
515
515
516 
		while(obsAlier.startsWith(",")) {
 516 
		while(obsAlier.startsWith(",")) {
517 
			obsAlier = obsAlier.replaceFirst(",", "");
 517 
			obsAlier = obsAlier.replaceFirst(",", "");
518 
		}
 518 
		}
519
519
520 
		if(nbObs > 0) {
 520 
		if(nbObs > 0) {
521
521
522 
			LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this);
 522 
			LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this);
523 
			lmcDAO.modifier(this,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obsAlier, motsClesEnCours);
 523 
			lmcDAO.modifier(this,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obsAlier, motsClesEnCours);
524 
		}
 524 
		}
525 
	}
 525 
	}
526
526
527
527
528 
	public void supprimerLiaisonMotCleObservations(
 528 
	public void supprimerLiaisonMotCleObservations(
529 
			Rafraichissable r, String idObs, String idMC) {
 529 
			Rafraichissable r, String idObs, String idMC) {
530
530
531 
		LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this);
 531 
		LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this);
532 
		lmcDAO.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idObs, idMC);
 532 
		lmcDAO.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idObs, idMC);
533
533
534 
	}
 534 
	}
535
535
536 
	/**
 536 
	/**
537 
	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
 537 
	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
538 
	 * fait la mise à jour de l'arbre des mots clés dans la base
 538 
	 * fait la mise à jour de l'arbre des mots clés dans la base
539 
	 *
539 
	 *
540 
	 * @param n
 540 
	 * @param n
541 
	 *            le nouveau noeud contenant le mot clé
 541 
	 *            le nouveau noeud contenant le mot clé
542 
	 * @param arbreMC
 542 
	 * @param arbreMC
543 
	 *            l'arbre des mots cles en cours
 543 
	 *            l'arbre des mots cles en cours
544 
	 */
 544 
	 */
545 
	public void ajouterMotCleDansArbre(TreeNode n,
 545 
	public void ajouterMotCleDansArbre(TreeNode n,
546 
			com.gwtext.client.data.Tree arbreMC, Rafraichissable r) {
 546 
			com.gwtext.client.data.Tree arbreMC, Rafraichissable r) {
547 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
 547 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
548 
 
 548 
 
549 
		String[] usObj = (String[]) n.getUserObject();
 549 
		String[] usObj = (String[]) n.getUserObject();
550 
		String motCle = usObj[0];
 550 
		String motCle = usObj[0];
551 
		String id = usObj[1];
 551 
		String id = usObj[1];
552 
		String parentId = "";
 552 
		String parentId = "";
553 
 
 553 
 
554 
		if (!id.equals("racine_obs")) {
 554 
		if (!id.equals("racine_obs")) {
555 
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
 555 
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
556 
			if(parentUsObj[1].equals("racine_obs")) {
 556 
			if(!parentUsObj[1].equals("racine_obs")) {
557 
				parentId= "";
 - 
 
558 
			} else {
 - 
 
559 
				parentId = parentUsObj[1];
 557 
				parentId = parentUsObj[1];
560 
			}
 558 
			}
561 
		} else {
 - 
 
562 
			parentId = "";
 - 
 
563 
		}
 559 
		}
564
560
565 
		rafraichirArbreMotsCles(arbreMC);
 561 
		rafraichirArbreMotsCles(arbreMC);
566 
		motsCles.put(id, motCle);
 562 
		motsCles.put(id, motCle);
567 
 
 563 
 
568 
		String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&motcle="
 564 
		String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&motcle="
569 
				+ motCle + "&id=" + id + "&parent=" + parentId;
 565 
				+ motCle + "&id=" + id + "&parent=" + parentId;
570 
		MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
 566 
		MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
571 
	}
 567 
	}
572 
 
 568 
 
573 
	/**
 569 
	/**
574 
	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
 570 
	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
575 
	 * supprimer les mots clés associés dans la base
 571 
	 * supprimer les mots clés associés dans la base
576 
	 *
572 
	 *
577 
	 * @param n
 573 
	 * @param n
578 
	 *            le noeud à supprimer
 574 
	 *            le noeud à supprimer
579 
	 * @param arbreMC
 575 
	 * @param arbreMC
580 
	 *            l'arbre des mots clés en cours
 576 
	 *            l'arbre des mots clés en cours
581 
	 */
 577 
	 */
582 
	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
 578 
	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
583 
 
 579 
 
584 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
 580 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
585 
 
 581 
 
586 
		String[] usObj = (String[]) n.getUserObject();
 582 
		String[] usObj = (String[]) n.getUserObject();
587 
		String id = usObj[1];
 583 
		String id = usObj[1];
588
584
589 
		rafraichirArbreMotsCles(arbreMC);
 585 
		rafraichirArbreMotsCles(arbreMC);
590 
 
 586 
 
591 
		MCDao.supprimerBaseDeDonnees(id);
 587 
		MCDao.supprimerBaseDeDonnees(id, r);
592 
 
 588 
 
593 
	}
 589 
	}
594 
 
 590 
 
595 
	/**
 591 
	/**
596 
	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
 592 
	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
597 
	 * DAO qui synchronise la modification dans la base de données
 593 
	 * DAO qui synchronise la modification dans la base de données
598 
	 *
594 
	 *
599 
	 * @param n
 595 
	 * @param n
600 
	 *            le noeud modifié
 596 
	 *            le noeud modifié
601 
	 * @param arbreMC
 597 
	 * @param arbreMC
602 
	 *            l'arbre des mots clés en cours
 598 
	 *            l'arbre des mots clés en cours
603 
	 */
 599 
	 */
604 
	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
 600 
	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
605 
 
 601 
 
606 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
 602 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
607 
 
 603 
 
608 
		String[] usObj = (String[]) n.getUserObject();
 604 
		String[] usObj = (String[]) n.getUserObject();
609 
		String motCle = usObj[0];
 605 
		String motCle = usObj[0];
610 
		String id = usObj[1];
 606 
		String id = usObj[1];
611 
		String parentId = "";
 607 
		String parentId = "";
612 
 
 608 
 
613 
		if (!id.equals("racine")) {
 609 
		if (!id.equals("racine_obs")) {
- 
 
 610 
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
614 
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
 611 
			if(!parentUsObj[1].equals("racine_obs")) {
615 
			parentId = parentUsObj[1];
 612 
				parentId = parentUsObj[1];
616 
		} else {
 - 
 
617 
			parentId = "racine";
 613 
			}
618 
		}
 614 
		}
619 
 
 615 
 
620 
		rafraichirArbreMotsCles(arbreMC);
 616 
		rafraichirArbreMotsCles(arbreMC);
621 
 
 617 
 
622 
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
 618 
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
623 
				+ parentId;
 619 
				+ parentId;
624 
		MCDao.modifierBaseDeDonnees(motCleModifie, r);
 620 
		MCDao.modifierBaseDeDonnees(motCleModifie, r);
625 
 
 621 
 
626 
	}
 622 
	}
627 
 
 623 
 
628 
	/**
 624 
	/**
629 
	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
 625 
	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
630 
	 * reorganise l'arbre dans la base de donnees suivant le changement
 626 
	 * reorganise l'arbre dans la base de donnees suivant le changement
631 
	 *
627 
	 *
632 
	 * @param n
 628 
	 * @param n
633 
	 *            le noeud deplace (et son sous arbre associe)
 629 
	 *            le noeud deplace (et son sous arbre associe)
634 
	 * @param arbreMC
 630 
	 * @param arbreMC
635 
	 *            l'arbre des mots cles en cours
 631 
	 *            l'arbre des mots cles en cours
636 
	 */
 632 
	 */
637 
	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
 633 
	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC, Rafraichissable r) {
638 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
 634 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
639 
 
 635 
 
640 
		String[] usObj = (String[]) n.getUserObject();
 636 
		String[] usObj = (String[]) n.getUserObject();
641 
		String motCle = usObj[0];
 637 
		String motCle = usObj[0];
642 
		String id = usObj[1];
 638 
		String id = usObj[1];
643 
		String parentId = "";
 639 
		String parentId = "";
- 
 
 640
644 
		if (!id.equals("racine_obs")) {
 641 
		if (!id.equals("racine_obs")) {
645 
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
 642 
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
- 
 
 643 
			if(!parentUsObj[1].equals("racine_obs")) {
646 
			parentId = parentUsObj[1];
 644 
				parentId = parentUsObj[1];
647 
		} else {
 645 
			}
648 
			parentId = "racine_obs";
 - 
 
649 
		}
 646 
		}
650
647
651 
		rafraichirArbreMotsCles(arbreMC);
 648 
		rafraichirArbreMotsCles(arbreMC);
652 
 
 649 
 
653 
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
 650 
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
654 
				+ parentId;
 651 
				+ parentId;
655 
		MCDao.deplacerBaseDeDonnees(motCleModifie, r);
 652 
		MCDao.deplacerBaseDeDonnees(motCleModifie, r);
656 
	}
 653 
	}
657
654
658 
	/**
 655 
	/**
659 
	 * Ajoute un nouveau mot clés à la liste des mots clés locale
 656 
	 * Ajoute un nouveau mot clés à la liste des mots clés locale
660 
	 *
657 
	 *
661 
	 * @param text
 658 
	 * @param text
662 
	 *            le mot clé
 659 
	 *            le mot clé
663 
	 * @param id
 660 
	 * @param id
664 
	 *            l'identifiant du mot clé
 661 
	 *            l'identifiant du mot clé
665 
	 */
 662 
	 */
666 
	public void mettreAjourMotsClesId(String text, String id) {
 663 
	public void mettreAjourMotsClesId(String text, String id) {
667 
		motsCles.put(id, text);
 664 
		motsCles.put(id, text);
668 
	}
 665 
	}
669
666
670 
	public String obtenirTexteMotCle(String id) {
 667 
	public String obtenirTexteMotCle(String id) {
671
668
672 
		String correspondanceId = "";
 669 
		String correspondanceId = "";
673
670
674 
		String motCleTexte = motsCles.get(id);
 671 
		String motCleTexte = motsCles.get(id);
675
672
676 
		if(motCleTexte != null) {
 673 
		if(motCleTexte != null) {
677 
			correspondanceId = motCleTexte;
 674 
			correspondanceId = motCleTexte;
678 
		}
 675 
		}
679
676
680 
		return correspondanceId;
 677 
		return correspondanceId;
681 
	}
 678 
	}
682
679
683 
	public void rafraichirCacheObservation(ListeObservation li) {
 680 
	public void rafraichirCacheObservation(ListeObservation li) {
684 
		cacheObservation = li ;
 681 
		cacheObservation = li ;
685 
	}
 682 
	}
686 
 
 683 
 
687 
	public ListeObservation getCacheObservation() {
 684 
	public ListeObservation getCacheObservation() {
688 
		return cacheObservation ;
 685 
		return cacheObservation ;
689 
	}
 686 
	}
690
687
691 
	public String getIdPourOrdreObs(String ordreObs) {
 688 
	public String getIdPourOrdreObs(String ordreObs) {
692 
		return (cacheObservation.get(ordreObs) != null) ? cacheObservation.get(ordreObs).getId() : null;
 689 
		return (cacheObservation.get(ordreObs) != null) ? cacheObservation.get(ordreObs).getId() : null;
693 
	}
 690 
	}
694 
 
 691 
 
695 
	public void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) {
 692 
	public void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) {
696 
		InformationCommuneDAO infocommune = new InformationCommuneDAO(r);
 693 
		InformationCommuneDAO infocommune = new InformationCommuneDAO(r);
697 
		infocommune.obtenirInfosCommune(r, nomCommune, codePostal);
 694 
		infocommune.obtenirInfosCommune(r, nomCommune, codePostal);
698 
	}
 695 
	}
699
696
700 
	public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) {
 697 
	public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) {
701 
		InformationCommuneDAO infocommune = new InformationCommuneDAO(r);
 698 
		InformationCommuneDAO infocommune = new InformationCommuneDAO(r);
702 
		infocommune.obtenirCommunePlusProche(r, lng, lat);
 699 
		infocommune.obtenirCommunePlusProche(r, lng, lat);
703 
	}
 700 
	}
704 
}
 701 
}