Subversion Repositories eFlore/Applications.del

Compare Revisions

Ignore whitespace Rev 940 → Rev 941

/trunk/src/org/tela_botanica/del/client/utils/UtilitairesServiceResultat.java
6,23 → 6,42
import java.util.Iterator;
import java.util.List;
 
import org.tela_botanica.del.client.cache.CacheClient;
import org.tela_botanica.del.client.modeles.Commentaire;
import org.tela_botanica.del.client.modeles.Contributeur;
import org.tela_botanica.del.client.modeles.Image;
import org.tela_botanica.del.client.modeles.ImageServiceResultat;
import org.tela_botanica.del.client.modeles.InterventionForum;
import org.tela_botanica.del.client.modeles.Observation;
import org.tela_botanica.del.client.modeles.ObservationServiceResultat;
import org.tela_botanica.del.client.modeles.PropositionDetermination;
import org.tela_botanica.del.client.modeles.Protocole;
import org.tela_botanica.del.client.modeles.ProtocoleServiceResultat;
import org.tela_botanica.del.client.modeles.Utilisateur;
import org.tela_botanica.del.client.modeles.VoteDetermination;
import org.tela_botanica.del.client.modeles.VoteProtocole;
 
import com.google.gwt.i18n.client.DateTimeFormat;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONValue;
 
/**
* Centralisation des methodes de parsing du code JSON retourné par les
* webservices
*
* @author LIENS
*
*/
public class UtilitairesServiceResultat {
 
/**
* Recupere un objet Image à partir du JSON
*
* @param imageJson
* @return
*/
public static Image parserImageJSON(JSONObject imageJson) {
 
Image image = new Image();
35,11 → 54,12
return image;
}
 
public static Observation parserObservationEtCreerPropositionDetermination(JSONObject observationJson) {
Observation observation = parserObservationJSON(observationJson);
return observation;
}
 
/**
* Recupere un objet Observation à partir du JSON
*
* @param imageJson
* @return
*/
public static Observation parserObservationJSON(JSONObject observationJson) {
 
Observation observation = new Observation();
76,6 → 96,34
return observation;
}
 
/**
* Créée une proposition de determination à partir d'une observation
*
* @param observation
* @return
*/
private static PropositionDetermination creerPropositionDeterminationAPartirObservation(Observation observation) {
 
String utilisateurNom = observation.getNomAuteur();
String utilisateurPrenom = observation.getPrenomAuteur();
String utilisateurCourriel = observation.getCourrielAuteur();
String utilisateurId = observation.getIdAuteur();
PropositionDetermination propositionDetermination = new PropositionDetermination(observation);
Contributeur contributeur = new Contributeur(utilisateurId, utilisateurNom, utilisateurPrenom, utilisateurCourriel);
propositionDetermination.setContributeur(contributeur);
java.util.Date datePropDeter = parserDateObservation(observation.getDateReleve());
propositionDetermination.setDate(datePropDeter);
propositionDetermination.setEspece(observation.getNomRetenu());
 
return propositionDetermination;
}
 
/**
* Recupere une liste de commentaires à partir du JSON
*
* @param imageJson
* @return
*/
public static List<Commentaire> parserCommentaires(JSONObject commentaires) {
List<InterventionForum> interventionForums = parserInterventions(commentaires);
List<Commentaire> commentairesListe = new ArrayList<Commentaire>();
88,6 → 136,12
 
}
 
/**
* Recupere une liste d'interventions à partir du JSON
*
* @param imageJson
* @return
*/
public static List<InterventionForum> parserInterventions(JSONObject interventions) {
HashMap<String, InterventionForum> interventionsNonTypees = new HashMap<String, InterventionForum>();
 
174,11 → 228,23
return retour;
}
 
/**
* Recupere une liste de commentaires à partir du JSON
*
* @param imageJson
* @return
*/
public static String convertirEtParserRetourAjoutCommentaire(String retour) {
JSONObject retourJson = JSONParser.parseStrict(retour).isObject();
return parserRetourAjoutCommentaire(retourJson);
}
 
/**
* Recupere une liste de commentaires à partir d'un objet JSON
*
* @param imageJson
* @return
*/
public static String parserRetourAjoutCommentaire(JSONObject retour) {
String id = "";
if (retour != null) {
191,22 → 257,12
return (objet.get(index) != null && objet.get(index).isString() != null) ? objet.get(index).isString().stringValue() : "";
}
 
public static PropositionDetermination creerPropositionDeterminationAPartirObservation(Observation observation) {
 
String utilisateurNom = observation.getNomAuteur();
String utilisateurPrenom = observation.getPrenomAuteur();
String utilisateurCourriel = observation.getCourrielAuteur();
String utilisateurId = observation.getIdAuteur();
PropositionDetermination propositionDetermination = new PropositionDetermination(observation);
Contributeur contributeur = new Contributeur(utilisateurId, utilisateurNom, utilisateurPrenom, utilisateurCourriel);
propositionDetermination.setContributeur(contributeur);
java.util.Date datePropDeter = parserDateObservation(observation.getDateReleve());
propositionDetermination.setDate(datePropDeter);
propositionDetermination.setEspece(observation.getNomRetenu());
 
return propositionDetermination;
}
 
/**
* Recupere une liste de votes sur une determination à partir du JSON
*
* @param imageJson
* @return
*/
public static HashMap<String, VoteDetermination> parserRetourListeVotesDetermination(String votesString) {
 
HashMap<String, VoteDetermination> retour = null;
219,6 → 275,13
return retour;
}
 
/**
* Recupere une liste de votes sur une determination à partir d'un objet
* JSON
*
* @param imageJson
* @return
*/
public static HashMap<String, VoteDetermination> parserVotesDetermination(JSONObject votes) {
HashMap<String, VoteDetermination> votesDetermination = new HashMap<String, VoteDetermination>();
java.util.Iterator<String> itVotes = votes.keySet().iterator();
241,6 → 304,12
return votesDetermination;
}
 
/**
* Recupere une liste de votes sur des images à partir d'un objet JSON
*
* @param imageJson
* @return
*/
public static HashMap<String, HashMap<String, VoteProtocole>> parserVotesProtocoles(JSONObject votes) {
 
HashMap<String, HashMap<String, VoteProtocole>> votesProtocoles = new HashMap<String, HashMap<String, VoteProtocole>>();
268,6 → 337,12
return votesProtocoles;
}
 
/**
* Recupere une date à partir du JSON
*
* @param imageJson
* @return
*/
public static Date parserDateObservation(String date) {
Date dateParsee = new Date();
DateTimeFormat formatDateObs = DateTimeFormat.getFormat("yyyy-MM-dd HH:mm:ss");
279,6 → 354,12
return dateParsee;
}
 
/**
* Recupere des mots-clefs à partir du JSON
*
* @param imageJson
* @return
*/
public static List<String> parserMotsCles(String motsClesTexte) {
String[] tabMotsCle = motsClesTexte.split(",");
List<String> motsClesParses = new ArrayList<String>();
297,6 → 378,12
return id;
}
 
/**
* Recupere un utilisateur à partir du JSON
*
* @param imageJson
* @return
*/
public static Utilisateur parserUtilisateurJson(JSONValue valeurJson) {
 
JSONObject utilisateurJson = valeurJson.isObject();
317,4 → 404,166
 
return utilisateur;
}
 
/**
* Retourne un objet {@link ProtocoleServiceResultat} à partir d'un objet
* JSON
*
* @param retourJson
* @return
*/
public static ProtocoleServiceResultat parserProtocoleServiceResultat(JSONValue retourJson) {
List<Protocole> protocoles = new ArrayList<Protocole>();
JSONObject tableauProto = retourJson.isObject().get("resultats").isObject();
 
if (tableauProto != null) {
java.util.Iterator<String> it = tableauProto.keySet().iterator();
while (it.hasNext()) {
 
JSONObject protocoleJSON = tableauProto.get(it.next()).isObject();
Protocole protocole = new Protocole();
String idProtocole = UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.id");
protocole.setId(Integer.parseInt(idProtocole));
protocole.setNom(UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.intitule"));
protocole.setDescription(UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.descriptif"));
protocoles.add(protocole);
}
}
 
return new ProtocoleServiceResultat(protocoles);
}
 
/**
* Retourne un objet {@link ImageServiceResultat} à partir du JSON
*
* @param retourJson
* @return
*/
public static ImageServiceResultat parserImageServiceResultat(JSONValue retourJson) {
 
ImageServiceResultat imageServiceResultat = new ImageServiceResultat();
int nbTotalImagesPourLaRecherche;
 
List<Image> images = new ArrayList<Image>();
// TODO ajouter vérifications plus précises
if (retourJson.isObject().get("entete") != null) {
double total = retourJson.isObject().get("entete").isObject().get("total").isNumber().doubleValue();
nbTotalImagesPourLaRecherche = (int) total;
JSONObject tableauImg = retourJson.isObject().get("resultats").isObject();
java.util.Iterator<String> it = tableauImg.keySet().iterator();
while (it.hasNext()) {
JSONObject imageJson = tableauImg.get(it.next()).isObject();
Image image = parserRetourImage(imageJson);
images.add(image);
}
 
} else {
JSONArray tableauImg = retourJson.isObject().get("images").isArray();
nbTotalImagesPourLaRecherche = (int) tableauImg.size();
for (int i = 0; i < nbTotalImagesPourLaRecherche; i++) {
JSONObject imageJson = tableauImg.get(i).isObject();
Image image = parserRetourImage(imageJson);
images.add(image);
}
}
 
imageServiceResultat.setImages(images);
imageServiceResultat.setNbTotalImagesPourLaRecherche(nbTotalImagesPourLaRecherche);
 
return imageServiceResultat;
 
}
 
/**
* Retourne un objet {@link Image} à partir du JSON
*
* @param retourJson
* @return
*/
public static Image parserRetourImage(JSONObject imageJson) {
Image image = UtilitairesServiceResultat.parserImageJSON(imageJson);
 
if (imageJson.get("observation") != null && imageJson.get("observation").isObject() != null) {
JSONObject observationJson = imageJson.get("observation").isObject();
image.setObservation(UtilitairesServiceResultat.parserObservationJSON(observationJson));
}
 
if (imageJson.get("protocoles_votes") != null && imageJson.get("protocoles_votes").isObject() != null) {
JSONObject votes = imageJson.get("protocoles_votes").isObject();
image.setVoteProtocoles(UtilitairesServiceResultat.parserVotesProtocoles(votes));
}
 
return image;
}
 
/**
* Retourne un objet {@link ObservationServiceResultat} à partir du JSON
*
* @param retourJson
* @return
*/
public static ObservationServiceResultat parserObservationServiceResultat(JSONValue retourJson) {
 
ObservationServiceResultat observationServiceResultat = new ObservationServiceResultat();
 
List<Observation> observations = new ArrayList<Observation>();
int nbTotalObservationsPourLaRecherche = 0;
 
if (retourJson.isObject().get("entete") != null) {
// TODO ajouter vérifications plus précises
double total = retourJson.isObject().get("entete").isObject().get("total").isNumber().doubleValue();
nbTotalObservationsPourLaRecherche = (int) total;
JSONObject tableauObs = retourJson.isObject().get("resultats").isObject();
 
if (tableauObs != null) {
java.util.Iterator<String> it = tableauObs.keySet().iterator();
while (it.hasNext()) {
JSONObject observationJson = tableauObs.get(it.next()).isObject();
Observation observation = analyserObservation(observationJson);
observations.add(observation);
}
}
} else {
JSONObject observationJson = retourJson.isObject();
Observation observation = analyserObservation(observationJson);
observations.add(observation);
CacheClient.getInstance().setObservationCourante(observation);
}
 
observationServiceResultat.setObservations(observations);
observationServiceResultat.setNbTotalObservationsPourLaRecherche(nbTotalObservationsPourLaRecherche);
 
return observationServiceResultat;
}
 
/**
* Retourne un objet {@link Observation} avec ses {@link Image} associées à
* partir du JSON
*
* @param retourJson
* @return
*/
private static Observation analyserObservation(JSONObject observationJson) {
Observation observation = UtilitairesServiceResultat.parserObservationJSON(observationJson);
JSONArray tableauImagesObs = observationJson.get("images").isArray();
List<Image> imagesPourObs = new ArrayList<Image>();
 
int nbImages = tableauImagesObs.size();
for (int j = 0; j < nbImages; j++) {
JSONObject imageJson = tableauImagesObs.get(j).isObject();
 
Image image = UtilitairesServiceResultat.parserImageJSON(imageJson);
if (imageJson.get("protocoles_votes") != null && imageJson.get("protocoles_votes").isObject() != null) {
JSONObject votes = imageJson.get("protocoles_votes").isObject();
image.setVoteProtocoles(UtilitairesServiceResultat.parserVotesProtocoles(votes));
}
image.setObservation(observation);
imagesPourObs.add(image);
}
 
observation.setImages(imagesPourObs);
 
return observation;
}
 
}