Subversion Repositories eFlore/Applications.del

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
500 aurelien 1
package org.tela_botanica.del.client.utils;
2
 
3
import java.util.ArrayList;
4
import java.util.Date;
5
import java.util.HashMap;
876 gduche 6
import java.util.Iterator;
500 aurelien 7
import java.util.List;
8
 
941 benjamin 9
import org.tela_botanica.del.client.cache.CacheClient;
876 gduche 10
import org.tela_botanica.del.client.modeles.Commentaire;
690 gduche 11
import org.tela_botanica.del.client.modeles.Contributeur;
500 aurelien 12
import org.tela_botanica.del.client.modeles.Image;
941 benjamin 13
import org.tela_botanica.del.client.modeles.ImageServiceResultat;
846 aurelien 14
import org.tela_botanica.del.client.modeles.InterventionForum;
500 aurelien 15
import org.tela_botanica.del.client.modeles.Observation;
941 benjamin 16
import org.tela_botanica.del.client.modeles.ObservationServiceResultat;
500 aurelien 17
import org.tela_botanica.del.client.modeles.PropositionDetermination;
941 benjamin 18
import org.tela_botanica.del.client.modeles.Protocole;
19
import org.tela_botanica.del.client.modeles.ProtocoleServiceResultat;
516 aurelien 20
import org.tela_botanica.del.client.modeles.Utilisateur;
846 aurelien 21
import org.tela_botanica.del.client.modeles.VoteDetermination;
500 aurelien 22
import org.tela_botanica.del.client.modeles.VoteProtocole;
23
 
24
import com.google.gwt.i18n.client.DateTimeFormat;
941 benjamin 25
import com.google.gwt.json.client.JSONArray;
500 aurelien 26
import com.google.gwt.json.client.JSONObject;
900 aurelien 27
import com.google.gwt.json.client.JSONParser;
516 aurelien 28
import com.google.gwt.json.client.JSONValue;
1104 gduche 29
import com.google.gwt.user.client.Window;
500 aurelien 30
 
941 benjamin 31
/**
32
 * Centralisation des methodes de parsing du code JSON retourné par les
33
 * webservices
34
 *
35
 * @author LIENS
36
 *
37
 */
500 aurelien 38
public class UtilitairesServiceResultat {
926 benjamin 39
 
941 benjamin 40
	/**
41
	 * Recupere un objet Image à partir du JSON
42
	 *
43
	 * @param imageJson
44
	 * @return
45
	 */
926 benjamin 46
	public static Image parserImageJSON(JSONObject imageJson) {
47
 
500 aurelien 48
		Image image = new Image();
763 aurelien 49
		String idImage = imageJson.get("id_image").isString().stringValue();
500 aurelien 50
		image.setIdImage(idImage);
926 benjamin 51
		image.setUrlFormat("http://www.tela-botanica.org/appli:cel-img:" + getIdAvecPadding(idImage) + "%s%.jpg");
52
		image.setUrl("http://www.tela-botanica.org/appli:cel-img:" + getIdAvecPadding(idImage) + "CRS.jpg");
53
		image.setMiniature("http://www.tela-botanica.org/appli:cel-img:" + getIdAvecPadding(idImage) + "XS.jpg");
1014 aurelien 54
		image.setMotsClefs(parserMotsCles(UtilitairesServiceResultat.getValeurOuVide(imageJson, "mots_cles_texte")));
926 benjamin 55
 
500 aurelien 56
		return image;
57
	}
926 benjamin 58
 
941 benjamin 59
	/**
60
	 * Recupere un objet Observation à partir du JSON
61
	 *
62
	 * @param imageJson
63
	 * @return
64
	 */
500 aurelien 65
	public static Observation parserObservationJSON(JSONObject observationJson) {
926 benjamin 66
 
500 aurelien 67
		Observation observation = new Observation();
926 benjamin 68
		observation.setAuteur(getValeurOuVide(observationJson, "auteur.prenom") + " " + getValeurOuVide(observationJson, "auteur.nom"));
69
		observation.setNomAuteur(getValeurOuVide(observationJson, "auteur.nom"));
1053 gduche 70
		observation.setPrenomAuteur(getValeurOuVide(observationJson, "auteur.prenom"));
926 benjamin 71
		observation.setIdAuteur(getValeurOuVide(observationJson, "auteur.id"));
72
		// TODO: renvoyer le courriel de l'auteur dans les obs
837 aurelien 73
		observation.setCourrielAuteur("");
926 benjamin 74
		observation.setDateTransmission(getValeurOuVide(observationJson, "date_observation"));
763 aurelien 75
		observation.setDateReleve(getValeurOuVide(observationJson, "date_observation"));
76
		observation.setFamille(getValeurOuVide(observationJson, "determination.famille"));
846 aurelien 77
		observation.setId(getValeurOuVide(observationJson, "id_observation"));
78
		observation.setIdLocalite(getValeurOuVide(observationJson, "id_zone_geo"));
79
		observation.setLocalite(getValeurOuVide(observationJson, "zone_geo"));
1062 benjamin 80
 
954 aurelien 81
		String nomRetenu = getValeurOuVide(observationJson, "determination.ns");
846 aurelien 82
		observation.setNomRetenu(getValeurOuVide(observationJson, "determination.ns"));
83
		observation.setMilieu(getValeurOuVide(observationJson, "milieu"));
84
		observation.setLieuDit(getValeurOuVide(observationJson, "lieudit"));
1026 gduche 85
		observation.setStation(getValeurOuVide(observationJson, "station"));
86
		observation.setCommentaire(getValeurOuVide(observationJson, "commentaire"));
846 aurelien 87
		observation.setNumNomenclatural(getValeurOuVide(observationJson, "determination.nn"));
1014 aurelien 88
		observation.setMotsClefs(parserMotsCles(UtilitairesServiceResultat.getValeurOuVide(observationJson, "mots_cles_texte")));
846 aurelien 89
		JSONValue propositions = observationJson.get("commentaires");
1062 benjamin 90
 
954 aurelien 91
		boolean creerPropositionAPartirObs = true;
926 benjamin 92
 
93
		if (propositions != null && propositions.isObject() != null) {
939 benjamin 94
			List<InterventionForum> interventions = parserInterventions(propositions.isObject());
95
			for (InterventionForum interventionForum : interventions) {
1062 benjamin 96
				interventionForum.setObservation(observation);
97
				// Si une proposition avec le même nom retenu que l'observation
98
				// est déjà présente,
99
				// alors il n'est pas nécessaire de créer la proposition
100
				// "factice"
101
				if (interventionForum instanceof PropositionDetermination) {
102
					PropositionDetermination proposition = (PropositionDetermination) interventionForum;
103
					if (!nomRetenu.equals("") && proposition.getEspece().equals(nomRetenu)) {
954 aurelien 104
						creerPropositionAPartirObs = false;
1131 aurelien 105
						proposition.setDate(parserDateObservation(observation.getDateReleve()));
954 aurelien 106
					}
1062 benjamin 107
				}
939 benjamin 108
			}
876 gduche 109
			observation.setInterventionsForum(interventions);
846 aurelien 110
		}
1062 benjamin 111
 
112
		if (creerPropositionAPartirObs) {
113
			// Si elle est nécessaire, la proposition factice est ajoutée au
114
			// début
954 aurelien 115
			observation.getInterventionsForum().add(0, creerPropositionDeterminationAPartirObservation(observation));
116
		}
500 aurelien 117
		return observation;
118
	}
926 benjamin 119
 
941 benjamin 120
	/**
121
	 * Créée une proposition de determination à partir d'une observation
122
	 *
123
	 * @param observation
124
	 * @return
125
	 */
126
	private static PropositionDetermination creerPropositionDeterminationAPartirObservation(Observation observation) {
127
 
128
		String utilisateurNom = observation.getNomAuteur();
129
		String utilisateurPrenom = observation.getPrenomAuteur();
1062 benjamin 130
 
941 benjamin 131
		String utilisateurCourriel = observation.getCourrielAuteur();
132
		String utilisateurId = observation.getIdAuteur();
133
		PropositionDetermination propositionDetermination = new PropositionDetermination(observation);
134
		Contributeur contributeur = new Contributeur(utilisateurId, utilisateurNom, utilisateurPrenom, utilisateurCourriel);
135
		propositionDetermination.setContributeur(contributeur);
136
		java.util.Date datePropDeter = parserDateObservation(observation.getDateReleve());
137
		propositionDetermination.setDate(datePropDeter);
138
		propositionDetermination.setEspece(observation.getNomRetenu());
139
 
140
		return propositionDetermination;
141
	}
142
 
143
	/**
144
	 * Recupere une liste de commentaires à partir du JSON
145
	 *
146
	 * @param imageJson
147
	 * @return
148
	 */
939 benjamin 149
	public static List<Commentaire> parserCommentaires(JSONObject commentaires) {
150
		List<InterventionForum> interventionForums = parserInterventions(commentaires);
926 benjamin 151
		List<Commentaire> commentairesListe = new ArrayList<Commentaire>();
152
		for (InterventionForum interventionForum : interventionForums) {
153
			if (interventionForum instanceof Commentaire) {
154
				commentairesListe.add((Commentaire) interventionForum);
155
			}
156
		}
157
		return commentairesListe;
158
 
159
	}
160
 
941 benjamin 161
	/**
162
	 * Recupere une liste d'interventions à partir du JSON
163
	 *
164
	 * @param imageJson
165
	 * @return
166
	 */
939 benjamin 167
	public static List<InterventionForum> parserInterventions(JSONObject interventions) {
889 gduche 168
		HashMap<String, InterventionForum> interventionsNonTypees = new HashMap<String, InterventionForum>();
926 benjamin 169
 
170
		List<InterventionForum> retour = new ArrayList<InterventionForum>();
939 benjamin 171
 
926 benjamin 172
		// parcourir les interventions et en faire un tableau
939 benjamin 173
		if (interventions == null) {
926 benjamin 174
			return retour;
175
		}
888 gduche 176
		Iterator<String> itInterventions = interventions.keySet().iterator();
177
		while (itInterventions.hasNext()) {
178
			JSONObject jsonIntervention = interventions.get(itInterventions.next()).isObject();
179
			String nomSel = getValeurOuVide(jsonIntervention, "nom_sel");
926 benjamin 180
 
888 gduche 181
			String id = getValeurOuVide(jsonIntervention, "id_commentaire");
981 aurelien 182
			String idParent = getValeurOuVide(jsonIntervention, "id_parent");
888 gduche 183
			String texte = getValeurOuVide(jsonIntervention, "texte");
926 benjamin 184
 
977 aurelien 185
			String idUtilisateur = getValeurOuVide(jsonIntervention, "auteur.id");
952 aurelien 186
			String nom = getValeurOuVide(jsonIntervention, "auteur.nom");
187
			String prenom = getValeurOuVide(jsonIntervention, "auteur.prenom");
188
			String courriel = getValeurOuVide(jsonIntervention, "auteur.courriel");
888 gduche 189
			Contributeur contributeur = new Contributeur(idUtilisateur, nom, prenom, courriel);
926 benjamin 190
 
965 aurelien 191
			Date date = parserDateObservation(getValeurOuVide(jsonIntervention, "date"));
926 benjamin 192
 
888 gduche 193
			if (!nomSel.equals("")) {
194
				String nom_sel = getValeurOuVide(jsonIntervention, "nom_sel");
195
				String nom_sel_nn = getValeurOuVide(jsonIntervention, "nom_sel_nn");
196
				String nom_ret = getValeurOuVide(jsonIntervention, "nom_ret");
197
				String nom_ret_nn = getValeurOuVide(jsonIntervention, "nom_ret_nn");
198
				String famille = getValeurOuVide(jsonIntervention, "famille");
199
				String nom_referentiel = getValeurOuVide(jsonIntervention, "nom_referentiel");
926 benjamin 200
 
920 aurelien 201
				String nbCommentaires = getValeurOuVide(jsonIntervention, "nb_commentaires");
926 benjamin 202
 
888 gduche 203
				PropositionDetermination intervention = new PropositionDetermination(id, contributeur, texte);
939 benjamin 204
				// intervention.setObservation(observation);
888 gduche 205
				intervention.setEspece(nom_sel);
926 benjamin 206
 
207
				if (!nbCommentaires.equals("")) {
933 aurelien 208
					int nbComm = Integer.parseInt(nbCommentaires);
1062 benjamin 209
					// if (!texte.equals("")) {
210
					// nbComm++;
211
					// }
933 aurelien 212
					intervention.setNbCommentaires(nbComm);
920 aurelien 213
				}
926 benjamin 214
 
1104 gduche 215
				if (nom_ret_nn != null && !nom_ret_nn.equals("")) {
216
					intervention.setNumNomenclatural(nom_ret_nn);
217
				}
218
 
888 gduche 219
				if (!idParent.equals("")) {
220
					intervention.setIdParent(idParent);
221
				}
926 benjamin 222
 
223
				if (jsonIntervention.get("votes") != null && jsonIntervention.get("votes").isObject() != null) {
939 benjamin 224
					intervention.setVotesDeterminations(parserVotesDetermination(jsonIntervention.get("votes").isObject()));
888 gduche 225
				}
926 benjamin 226
 
888 gduche 227
				intervention.setDate(date);
889 gduche 228
				interventionsNonTypees.put(intervention.getId(), intervention);
926 benjamin 229
 
888 gduche 230
			} else {
231
				Commentaire intervention = new Commentaire(contributeur, date, texte);
893 gduche 232
				intervention.setId(id);
888 gduche 233
				intervention.setDate(date);
889 gduche 234
				interventionsNonTypees.put(intervention.getId(), intervention);
893 gduche 235
				if (!idParent.equals("")) {
236
					intervention.setIdParent(idParent);
237
				}
888 gduche 238
			}
239
		}
240
 
889 gduche 241
		Iterator<String> itIntervention = interventionsNonTypees.keySet().iterator();
242
		while (itIntervention.hasNext()) {
243
			String id = itIntervention.next();
244
			InterventionForum intervention = interventionsNonTypees.get(id);
245
			String idParent = intervention.getIdParent();
1003 benjamin 246
			if (idParent != null && !idParent.equals("") && !idParent.equals("0") && interventionsNonTypees.containsKey(idParent)) {
893 gduche 247
				InterventionForum parent = interventionsNonTypees.get(idParent);
248
				intervention.setParent(parent);
1062 benjamin 249
				parent.ajouterCommentaire((Commentaire) intervention);
250
			} else {
1003 benjamin 251
				retour.add(intervention);
252
			}
889 gduche 253
		}
926 benjamin 254
 
889 gduche 255
		return retour;
500 aurelien 256
	}
939 benjamin 257
 
941 benjamin 258
	/**
259
	 * Recupere une liste de commentaires à partir du JSON
260
	 *
261
	 * @param imageJson
262
	 * @return
263
	 */
931 aurelien 264
	public static String convertirEtParserRetourAjoutCommentaire(String retour) {
929 aurelien 265
		JSONObject retourJson = JSONParser.parseStrict(retour).isObject();
266
		return parserRetourAjoutCommentaire(retourJson);
267
	}
926 benjamin 268
 
941 benjamin 269
	/**
270
	 * Recupere une liste de commentaires à partir d'un objet JSON
271
	 *
272
	 * @param imageJson
273
	 * @return
274
	 */
884 aurelien 275
	public static String parserRetourAjoutCommentaire(JSONObject retour) {
276
		String id = "";
926 benjamin 277
		if (retour != null) {
884 aurelien 278
			id = getValeurOuVide(retour, "id_commentaire");
279
		}
280
		return id;
281
	}
926 benjamin 282
 
888 gduche 283
	public static String getValeurOuVide(JSONObject objet, String index) {
920 aurelien 284
		return (objet.get(index) != null && objet.get(index).isString() != null) ? objet.get(index).isString().stringValue() : "";
888 gduche 285
	}
926 benjamin 286
 
941 benjamin 287
	/**
288
	 * Recupere une liste de votes sur une determination à partir du JSON
289
	 *
290
	 * @param imageJson
291
	 * @return
292
	 */
939 benjamin 293
	public static HashMap<String, VoteDetermination> parserRetourListeVotesDetermination(String votesString) {
900 aurelien 294
 
295
		HashMap<String, VoteDetermination> retour = null;
926 benjamin 296
 
900 aurelien 297
		JSONObject votes = JSONParser.parseStrict(votesString).isObject();
926 benjamin 298
		if (votes != null && votes.get("resultats") != null && votes.get("resultats").isObject() != null) {
900 aurelien 299
			JSONObject resultat = votes.get("resultats").isObject();
939 benjamin 300
			retour = parserVotesDetermination(resultat);
900 aurelien 301
		}
302
		return retour;
303
	}
926 benjamin 304
 
941 benjamin 305
	/**
306
	 * Recupere une liste de votes sur une determination à partir d'un objet
307
	 * JSON
308
	 *
309
	 * @param imageJson
310
	 * @return
311
	 */
939 benjamin 312
	public static HashMap<String, VoteDetermination> parserVotesDetermination(JSONObject votes) {
846 aurelien 313
		HashMap<String, VoteDetermination> votesDetermination = new HashMap<String, VoteDetermination>();
314
		java.util.Iterator<String> itVotes = votes.keySet().iterator();
315
		while (itVotes.hasNext()) {
316
			JSONObject vote = votes.get(itVotes.next()).isObject();
317
			VoteDetermination vd = new VoteDetermination();
318
			vd.setContributeur(getValeurOuVide(vote, "auteur.id"));
965 aurelien 319
			vd.setDate(parserDateObservation(getValeurOuVide(vote, "date")));
846 aurelien 320
			vd.setId(getValeurOuVide(vote, "vote.id"));
321
			vd.setVote(Integer.parseInt(getValeurOuVide(vote, "vote")));
900 aurelien 322
			vd.setContributeur(getValeurOuVide(vote, "auteur.id"));
926 benjamin 323
 
324
			if (vote.get("auteur.nom") != null && vote.get("auteur.nom") != null && vote.get("auteur.courriel") != null) {
325
				Contributeur auteur = new Contributeur(getValeurOuVide(vote, "auteur.id"), getValeurOuVide(vote, "auteur.nom"), getValeurOuVide(vote, "auteur.prenom"), getValeurOuVide(vote, "auteur.courriel"));
900 aurelien 326
				vd.setAuteur(auteur);
327
			}
926 benjamin 328
 
846 aurelien 329
			votesDetermination.put(getValeurOuVide(vote, "auteur.id"), vd);
926 benjamin 330
		}
846 aurelien 331
		return votesDetermination;
332
	}
926 benjamin 333
 
941 benjamin 334
	/**
335
	 * Recupere une liste de votes sur des images à partir d'un objet JSON
336
	 *
337
	 * @param imageJson
338
	 * @return
339
	 */
926 benjamin 340
	public static HashMap<String, HashMap<String, VoteProtocole>> parserVotesProtocoles(JSONObject votes) {
341
 
342
		HashMap<String, HashMap<String, VoteProtocole>> votesProtocoles = new HashMap<String, HashMap<String, VoteProtocole>>();
777 aurelien 343
		java.util.Iterator<String> itProtocoles = votes.keySet().iterator();
926 benjamin 344
		while (itProtocoles.hasNext()) {
345
			JSONObject protocole = votes.get(itProtocoles.next()).isObject();
777 aurelien 346
			JSONObject votesPourCeProtocoles = protocole.get("votes").isObject();
347
			String idProtocoleVote = protocole.get("protocole.id").isString().stringValue();
348
			java.util.Iterator<String> itVotes = votesPourCeProtocoles.keySet().iterator();
926 benjamin 349
			while (itVotes.hasNext()) {
777 aurelien 350
				JSONObject voteEnCours = votesPourCeProtocoles.get(itVotes.next()).isObject();
351
				VoteProtocole vd = new VoteProtocole();
352
				vd.setContributeur(voteEnCours.get("auteur.id").isString().stringValue());
353
				// TODO récupérer la date du vote et la parser
965 aurelien 354
				vd.setDate(parserDateObservation(getValeurOuVide(voteEnCours, "date")));
777 aurelien 355
				int valeurVote = Integer.parseInt(voteEnCours.get("vote").isString().stringValue());
356
				vd.setVote(valeurVote);
926 benjamin 357
				if (!votesProtocoles.containsKey(idProtocoleVote)) {
358
					votesProtocoles.put(idProtocoleVote, new HashMap<String, VoteProtocole>());
777 aurelien 359
				}
360
				votesProtocoles.get(idProtocoleVote).put(vd.getContributeur(), vd);
500 aurelien 361
			}
362
		}
926 benjamin 363
 
500 aurelien 364
		return votesProtocoles;
365
	}
926 benjamin 366
 
941 benjamin 367
	/**
368
	 * Recupere une date à partir du JSON
369
	 *
370
	 * @param imageJson
371
	 * @return
372
	 */
500 aurelien 373
	public static Date parserDateObservation(String date) {
374
		Date dateParsee = new Date();
965 aurelien 375
		DateTimeFormat formatDateObs = DateTimeFormat.getFormat("yyyy-MM-dd HH:mm:ss");
926 benjamin 376
		try {
377
			dateParsee = formatDateObs.parse(date);
378
		} catch (IllegalArgumentException e) {
379
			dateParsee = new java.sql.Date(0);
500 aurelien 380
		}
926 benjamin 381
		return dateParsee;
500 aurelien 382
	}
926 benjamin 383
 
941 benjamin 384
	/**
385
	 * Recupere des mots-clefs à partir du JSON
386
	 *
387
	 * @param imageJson
388
	 * @return
389
	 */
500 aurelien 390
	public static List<String> parserMotsCles(String motsClesTexte) {
391
		String[] tabMotsCle = motsClesTexte.split(",");
392
		List<String> motsClesParses = new ArrayList<String>();
393
		for (int i = 0; i < tabMotsCle.length; i++) {
1014 aurelien 394
			motsClesParses.add(tabMotsCle[i].trim());
500 aurelien 395
		}
926 benjamin 396
 
500 aurelien 397
		return motsClesParses;
398
	}
926 benjamin 399
 
500 aurelien 400
	public static String getIdAvecPadding(String id) {
401
		int maxZeros = 9 - id.length();
402
		for (int i = 0; i < maxZeros; i++) {
403
			id = "0" + id;
404
		}
405
		return id;
406
	}
926 benjamin 407
 
941 benjamin 408
	/**
409
	 * Recupere un utilisateur à partir du JSON
410
	 *
411
	 * @param imageJson
412
	 * @return
413
	 */
516 aurelien 414
	public static Utilisateur parserUtilisateurJson(JSONValue valeurJson) {
926 benjamin 415
 
516 aurelien 416
		JSONObject utilisateurJson = valeurJson.isObject();
417
		boolean connecteUtilisateur = utilisateurJson.get("connecte").isBoolean().booleanValue();
418
		String idUtilisateur = utilisateurJson.get("id_utilisateur").isString().stringValue();
926 benjamin 419
 
516 aurelien 420
		Utilisateur utilisateur;
926 benjamin 421
 
422
		if (connecteUtilisateur) {
522 aurelien 423
			String courrielUtilisateur = utilisateurJson.get("courriel").isString().stringValue();
516 aurelien 424
			String nomUtilisateur = utilisateurJson.get("nom").isString().stringValue();
425
			String prenomUtilisateur = utilisateurJson.get("prenom").isString().stringValue();
926 benjamin 426
 
516 aurelien 427
			utilisateur = new Utilisateur(idUtilisateur, prenomUtilisateur, nomUtilisateur, courrielUtilisateur);
428
		} else {
429
			utilisateur = new Utilisateur(idUtilisateur);
430
		}
926 benjamin 431
 
516 aurelien 432
		return utilisateur;
433
	}
941 benjamin 434
 
435
	/**
436
	 * Retourne un objet {@link ProtocoleServiceResultat} à partir d'un objet
437
	 * JSON
438
	 *
439
	 * @param retourJson
440
	 * @return
441
	 */
442
	public static ProtocoleServiceResultat parserProtocoleServiceResultat(JSONValue retourJson) {
443
		List<Protocole> protocoles = new ArrayList<Protocole>();
444
		JSONObject tableauProto = retourJson.isObject().get("resultats").isObject();
445
 
446
		if (tableauProto != null) {
447
			java.util.Iterator<String> it = tableauProto.keySet().iterator();
448
			while (it.hasNext()) {
449
 
450
				JSONObject protocoleJSON = tableauProto.get(it.next()).isObject();
451
				Protocole protocole = new Protocole();
452
				String idProtocole = UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.id");
453
				protocole.setId(Integer.parseInt(idProtocole));
454
				protocole.setNom(UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.intitule"));
455
				protocole.setDescription(UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.descriptif"));
456
				protocoles.add(protocole);
457
			}
458
		}
459
 
460
		return new ProtocoleServiceResultat(protocoles);
461
	}
462
 
463
	/**
464
	 * Retourne un objet {@link ImageServiceResultat} à partir du JSON
465
	 *
466
	 * @param retourJson
467
	 * @return
468
	 */
469
	public static ImageServiceResultat parserImageServiceResultat(JSONValue retourJson) {
470
 
471
		ImageServiceResultat imageServiceResultat = new ImageServiceResultat();
472
		int nbTotalImagesPourLaRecherche;
473
 
474
		List<Image> images = new ArrayList<Image>();
475
		// TODO ajouter vérifications plus précises
476
		if (retourJson.isObject().get("entete") != null) {
477
			double total = retourJson.isObject().get("entete").isObject().get("total").isNumber().doubleValue();
478
			nbTotalImagesPourLaRecherche = (int) total;
479
			JSONObject tableauImg = retourJson.isObject().get("resultats").isObject();
1062 benjamin 480
			if (tableauImg != null) {
481
				java.util.Iterator<String> it = tableauImg.keySet().iterator();
482
				while (it.hasNext()) {
483
					JSONObject imageJson = tableauImg.get(it.next()).isObject();
484
					Image image = parserRetourImage(imageJson);
485
					images.add(image);
486
				}
941 benjamin 487
			}
488
 
489
		} else {
490
			JSONArray tableauImg = retourJson.isObject().get("images").isArray();
491
			nbTotalImagesPourLaRecherche = (int) tableauImg.size();
492
			for (int i = 0; i < nbTotalImagesPourLaRecherche; i++) {
493
				JSONObject imageJson = tableauImg.get(i).isObject();
494
				Image image = parserRetourImage(imageJson);
495
				images.add(image);
496
			}
497
		}
498
 
499
		imageServiceResultat.setImages(images);
500
		imageServiceResultat.setNbTotalImagesPourLaRecherche(nbTotalImagesPourLaRecherche);
501
 
502
		return imageServiceResultat;
503
 
504
	}
505
 
506
	/**
507
	 * Retourne un objet {@link Image} à partir du JSON
508
	 *
509
	 * @param retourJson
510
	 * @return
511
	 */
512
	public static Image parserRetourImage(JSONObject imageJson) {
513
		Image image = UtilitairesServiceResultat.parserImageJSON(imageJson);
514
 
515
		if (imageJson.get("observation") != null && imageJson.get("observation").isObject() != null) {
516
			JSONObject observationJson = imageJson.get("observation").isObject();
517
			image.setObservation(UtilitairesServiceResultat.parserObservationJSON(observationJson));
518
		}
519
 
520
		if (imageJson.get("protocoles_votes") != null && imageJson.get("protocoles_votes").isObject() != null) {
521
			JSONObject votes = imageJson.get("protocoles_votes").isObject();
522
			image.setVoteProtocoles(UtilitairesServiceResultat.parserVotesProtocoles(votes));
523
		}
524
 
525
		return image;
526
	}
527
 
528
	/**
529
	 * Retourne un objet {@link ObservationServiceResultat} à partir du JSON
530
	 *
531
	 * @param retourJson
532
	 * @return
533
	 */
534
	public static ObservationServiceResultat parserObservationServiceResultat(JSONValue retourJson) {
535
 
536
		ObservationServiceResultat observationServiceResultat = new ObservationServiceResultat();
537
 
538
		List<Observation> observations = new ArrayList<Observation>();
539
		int nbTotalObservationsPourLaRecherche = 0;
540
 
541
		if (retourJson.isObject().get("entete") != null) {
542
			// TODO ajouter vérifications plus précises
543
			double total = retourJson.isObject().get("entete").isObject().get("total").isNumber().doubleValue();
544
			nbTotalObservationsPourLaRecherche = (int) total;
545
			JSONObject tableauObs = retourJson.isObject().get("resultats").isObject();
546
 
547
			if (tableauObs != null) {
548
				java.util.Iterator<String> it = tableauObs.keySet().iterator();
549
				while (it.hasNext()) {
550
					JSONObject observationJson = tableauObs.get(it.next()).isObject();
551
					Observation observation = analyserObservation(observationJson);
552
					observations.add(observation);
553
				}
554
			}
555
		} else {
556
			JSONObject observationJson = retourJson.isObject();
557
			Observation observation = analyserObservation(observationJson);
558
			observations.add(observation);
559
			CacheClient.getInstance().setObservationCourante(observation);
560
		}
561
 
562
		observationServiceResultat.setObservations(observations);
563
		observationServiceResultat.setNbTotalObservationsPourLaRecherche(nbTotalObservationsPourLaRecherche);
564
 
565
		return observationServiceResultat;
566
	}
567
 
568
	/**
569
	 * Retourne un objet {@link Observation} avec ses {@link Image} associées à
570
	 * partir du JSON
571
	 *
572
	 * @param retourJson
573
	 * @return
574
	 */
575
	private static Observation analyserObservation(JSONObject observationJson) {
576
		Observation observation = UtilitairesServiceResultat.parserObservationJSON(observationJson);
577
		JSONArray tableauImagesObs = observationJson.get("images").isArray();
578
		List<Image> imagesPourObs = new ArrayList<Image>();
579
 
580
		int nbImages = tableauImagesObs.size();
581
		for (int j = 0; j < nbImages; j++) {
582
			JSONObject imageJson = tableauImagesObs.get(j).isObject();
583
 
584
			Image image = UtilitairesServiceResultat.parserImageJSON(imageJson);
585
			if (imageJson.get("protocoles_votes") != null && imageJson.get("protocoles_votes").isObject() != null) {
586
				JSONObject votes = imageJson.get("protocoles_votes").isObject();
587
				image.setVoteProtocoles(UtilitairesServiceResultat.parserVotesProtocoles(votes));
588
			}
589
			image.setObservation(observation);
590
			imagesPourObs.add(image);
591
		}
592
 
593
		observation.setImages(imagesPourObs);
594
 
595
		return observation;
596
	}
597
 
1151 aurelien 598
	public static List<String> parserRetourListeMotsClesImage(JSONObject retourJson) {
599
		List<String> motsCles = new ArrayList<String>();
600
		JSONObject tableauMc = retourJson;
601
		if (tableauMc != null) {
602
			java.util.Iterator<String> it = tableauMc.keySet().iterator();
603
			while (it.hasNext()) {
604
				JSONObject mc = tableauMc.get(it.next()).isObject();
605
				motsCles.add(getValeurOuVide(mc, "mot_cle"));
606
			}
607
		}
608
		return motsCles;
609
	}
500 aurelien 610
}