| New file |
|---|
| 0,0 → 1,854 |
|---|
| package org.tela_botanica.del.client.utils; |
| |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.tela_botanica.del.client.Del; |
| import org.tela_botanica.del.client.cache.CacheClient; |
| import org.tela_botanica.del.client.config.Config; |
| import org.tela_botanica.del.client.i18n.I18n; |
| import org.tela_botanica.del.client.modeles.ActiviteUtilisateur; |
| import org.tela_botanica.del.client.modeles.AuthInfo; |
| import org.tela_botanica.del.client.modeles.Commentaire; |
| import org.tela_botanica.del.client.modeles.Contributeur; |
| import org.tela_botanica.del.client.modeles.EvenementObs; |
| 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.MotCle; |
| 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.core.shared.GWT; |
| import com.google.gwt.i18n.client.DateTimeFormat; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONString; |
| 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(); |
| Config config = new Config(); |
| String urlImages = config.getUrl("images"); |
| String idImage = imageJson.get("id_image").isString().stringValue(); |
| image.setIdImage(idImage); |
| image.setUrlFormat(urlImages + getIdAvecPadding(idImage) + "%s%.jpg"); |
| image.setUrl(urlImages + getIdAvecPadding(idImage) + "CRS.jpg"); |
| image.setMiniature(urlImages + getIdAvecPadding(idImage) + "XS.jpg"); |
| image.setMotsClefs(parserMotsCles(UtilitairesServiceResultat.getValeurOuVide(imageJson, "mots_cles_texte"))); |
| |
| return image; |
| } |
| |
| /** |
| * Recupere un objet Observation à partir du JSON |
| * |
| * @param imageJson |
| * @return |
| */ |
| public static Observation parserObservationJSON(JSONObject observationJson) { |
| |
| Observation observation = new Observation(); |
| observation.setAuteur(getValeurOuVide(observationJson, "auteur.prenom") + " " + getValeurOuVide(observationJson, "auteur.nom")); |
| observation.setNomAuteur(getValeurOuVide(observationJson, "auteur.nom")); |
| observation.setPrenomAuteur(getValeurOuVide(observationJson, "auteur.prenom")); |
| observation.setIdAuteur(getValeurOuVide(observationJson, "auteur.id")); |
| // TODO: renvoyer le courriel de l'auteur dans les obs |
| observation.setCourrielAuteur(getValeurOuVide(observationJson, "auteur.courriel")); |
| observation.setDateTransmission(getValeurOuVide(observationJson, "date_transmission")); |
| observation.setDateReleve(getValeurOuVide(observationJson, "date_observation")); |
| observation.setFamille(getValeurOuVide(observationJson, "determination.famille")); |
| observation.setId(getValeurOuVide(observationJson, "id_observation")); |
| observation.setPays(getValeurOuVide(observationJson, "pays")); |
| observation.setIdLocalite(getValeurOuVide(observationJson, "id_zone_geo")); |
| observation.setLocalite(getValeurOuVide(observationJson, "zone_geo")); |
| |
| String nomRetenu = getValeurOuVide(observationJson, "determination.ns"); |
| // Pour afficher quelque chose de plus pertinent qu'un nom vide |
| // (il en existe parfois et cela fausse l'affichage) |
| if(nomRetenu.trim().isEmpty()) { |
| nomRetenu = I18n.getVocabulary().indeterminee(); |
| } |
| observation.setNomRetenu(nomRetenu); |
| observation.setMilieu(getValeurOuVide(observationJson, "milieu")); |
| observation.setLieuDit(getValeurOuVide(observationJson, "lieudit")); |
| observation.setStation(getValeurOuVide(observationJson, "station")); |
| observation.setCommentaire(getValeurOuVide(observationJson, "commentaire")); |
| observation.setNumNomenclatural(getValeurOuVide(observationJson, "determination.nn")); |
| observation.setReferentiel(getValeurOuVide(observationJson, "determination.referentiel")); |
| String nbCom = getValeurOuVide(observationJson, "nb_commentaires"); |
| nbCom = nbCom.equals("") ? "0" : nbCom; |
| observation.setNbCommentaires(nbCom); |
| observation.setMotsClefs(parserMotsCles(UtilitairesServiceResultat.getValeurOuVide(observationJson, "mots_cles_texte"))); |
| JSONValue propositions = observationJson.get("commentaires"); |
| |
| JSONValue evenements = observationJson.get("evenements"); |
| List<EvenementObs> evenementsObs = new ArrayList<EvenementObs>(); |
| if (evenements != null && evenements.isArray() != null) { |
| JSONArray evenementsTab = evenements.isArray(); |
| for (int i = 0; i < evenementsTab.size(); i++) { |
| String type = evenementsTab.get(i).isObject().get("type").isString().stringValue(); |
| String infosComplementaires = evenementsTab.get(i).isObject().get("infos_complementaires").isString().stringValue(); |
| EvenementObs evtObs = new EvenementObs(type, infosComplementaires); |
| evenementsObs.add(evtObs); |
| } |
| } |
| observation.setEvenementsAssocies(evenementsObs); |
| |
| boolean creerPropositionAPartirObs = true; |
| boolean propositionInitialeExiste = false; |
| PropositionDetermination propositionPotentiellementInitiale = null; |
| if (propositions != null && propositions.isObject() != null) { |
| List<InterventionForum> interventions = parserInterventions(propositions.isObject()); |
| |
| for (InterventionForum interventionForum : interventions) { |
| interventionForum.setObservation(observation); |
| if (interventionForum instanceof PropositionDetermination) { |
| PropositionDetermination proposition = (PropositionDetermination) interventionForum; |
| // Si une proposition avec les même nums noms et référentiel que l'observation est déjà présente, |
| // alors il n'est pas nécessaire de créer la proposition "factice" |
| if (especePropositionEtObservationCorrespondent(observation, proposition)) { |
| creerPropositionAPartirObs = false; |
| // Si de plus les auteurs correspondent, alors nous avons affaire à la proposition initiale |
| if(proposition.getContributeur().getNomComplet().equals(observation.getAuteur())) { |
| propositionPotentiellementInitiale = proposition; |
| } |
| } |
| |
| if (proposition.estPropositionInitiale()) { |
| propositionInitialeExiste = true; |
| } |
| } |
| } |
| observation.setInterventionsForum(interventions); |
| } |
| |
| if (!propositionInitialeExiste && propositionPotentiellementInitiale != null) { |
| // Ceci permet à la la proposition d'être mise en valeur différemment dans l'interface |
| propositionPotentiellementInitiale.setEstPropositionInitiale(true); |
| } |
| |
| if (creerPropositionAPartirObs) { |
| // Si elle est nécessaire, la proposition factice est ajoutée au début |
| observation.getInterventionsForum().add(0, creerPropositionDeterminationAPartirObservation(observation, propositionInitialeExiste)); |
| } |
| return observation; |
| |
| } |
| |
| public static boolean especePropositionEtObservationCorrespondent(Observation observation, PropositionDetermination proposition) { |
| boolean correspondent = false; |
| String obsNN = observation.getNumNomenclatural(); |
| String obsRef = observation.getReferentiel(); |
| String propNN = proposition.getNumNomenclatural(); |
| String propRef = proposition.getReferentiel(); |
| boolean obnNNVide = obsNN == null || obsNN.isEmpty() || obsNN.equals("0"); |
| boolean propNNVide = propNN == null || propNN.isEmpty() || propNN.equals("0"); |
| |
| /*Del.LogVersFirebug( |
| "OBS NN: [" + obsNN |
| + "], OBS REF: [" + obsRef |
| + "], PROP NN: [" + propNN |
| //+ "], PROP NS: [" + proposition.getEspece() |
| + "], PROP REF: [" + propRef |
| + "]" |
| );*/ |
| |
| // @WARNING patch crado en raison d'une conception poucrave de cette appli cliente : la |
| // présence d'une obs non liée à un référentiel, même si ce n'est pas celle qui est |
| // actuellement retenue, entraînera une disparition de la proposition actuellement retenue; |
| // mais ce n'est pas censé arriver, car à la première création d'une proposition, la |
| // proposition initiale doit être matérialisée (j'ai bon ? pas sûr :P) |
| |
| // soit les NN sont à zéro ou null (proposition non liée) et dans ce cas on ne compare pas les référentiels |
| if (propNNVide && obnNNVide) { |
| correspondent = true; |
| } else { // soit on compare les NN et les référentiels |
| correspondent = (obsNN.equals(propNN) && obsRef.equals(propRef)); |
| } |
| |
| return correspondent; |
| } |
| |
| /** |
| * Créée une proposition de determination à partir d'une observation |
| * |
| * @param observation |
| * @return |
| */ |
| private static PropositionDetermination creerPropositionDeterminationAPartirObservation(Observation observation, boolean propositionInitialeExiste) { |
| |
| 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.getDateTransmission()); |
| propositionDetermination.setDate(datePropDeter); |
| |
| propositionDetermination.setEspece(observation.getNomRetenu()); |
| propositionDetermination.setNumNomenclatural(observation.getNumNomenclatural()); |
| propositionDetermination.setReferentiel(observation.getReferentiel()); |
| if (!propositionInitialeExiste) { |
| propositionDetermination.setEstPropositionInitiale(true); |
| } |
| |
| |
| 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>(); |
| for (InterventionForum interventionForum : interventionForums) { |
| if (interventionForum instanceof Commentaire) { |
| commentairesListe.add((Commentaire) interventionForum); |
| } |
| } |
| return commentairesListe; |
| |
| } |
| |
| /** |
| * 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>(); |
| |
| List<InterventionForum> retour = new ArrayList<InterventionForum>(); |
| |
| // parcourir les interventions et en faire un tableau |
| if (interventions == null) { |
| return retour; |
| } |
| Iterator<String> itInterventions = interventions.keySet().iterator(); |
| while (itInterventions.hasNext()) { |
| JSONObject jsonIntervention = interventions.get(itInterventions.next()).isObject(); |
| String nomSel = getValeurOuVide(jsonIntervention, "nom_sel"); |
| |
| String id = getValeurOuVide(jsonIntervention, "id_commentaire"); |
| String idParent = getValeurOuVide(jsonIntervention, "id_parent"); |
| String texte = getValeurOuVide(jsonIntervention, "texte"); |
| |
| String idUtilisateur = getValeurOuVide(jsonIntervention, "auteur.id"); |
| String nom = getValeurOuVide(jsonIntervention, "auteur.nom"); |
| String prenom = getValeurOuVide(jsonIntervention, "auteur.prenom"); |
| String courriel = getValeurOuVide(jsonIntervention, "auteur.courriel"); |
| Contributeur contributeur = new Contributeur(idUtilisateur, nom, prenom, courriel); |
| |
| Date date = parserDateObservation(getValeurOuVide(jsonIntervention, "date")); |
| |
| if (!nomSel.equals("")) { |
| String nom_sel = getValeurOuVide(jsonIntervention, "nom_sel"); |
| String nom_sel_nn = getValeurOuVide(jsonIntervention, "nom_sel_nn"); |
| String nom_ret = getValeurOuVide(jsonIntervention, "nom_ret"); |
| String nom_ret_nn = getValeurOuVide(jsonIntervention, "nom_ret_nn"); |
| String famille = getValeurOuVide(jsonIntervention, "famille"); |
| String nom_referentiel = getValeurOuVide(jsonIntervention, "nom_referentiel"); |
| |
| String nbCommentaires = getValeurOuVide(jsonIntervention, "nb_commentaires"); |
| |
| PropositionDetermination intervention = new PropositionDetermination(id, contributeur, texte); |
| String proposition_initiale = getValeurOuVide(jsonIntervention, "proposition_initiale"); |
| if (proposition_initiale != null && proposition_initiale.equals("1")) { |
| intervention.setEstPropositionInitiale(true); |
| } |
| |
| String proposition_retenue = getValeurOuVide(jsonIntervention, "proposition_retenue"); |
| if (proposition_retenue != null && proposition_retenue.equals("1")) { |
| intervention.setEstPropositionRetenue(true); |
| } |
| |
| intervention.setEspece(nom_sel); |
| |
| if (!nbCommentaires.equals("")) { |
| int nbComm = Integer.parseInt(nbCommentaires); |
| intervention.setNbCommentaires(nbComm); |
| } |
| |
| if (nom_sel_nn != null && !nom_sel_nn.equals("")) { |
| intervention.setNumNomenclatural(nom_sel_nn); |
| } |
| |
| if(nom_referentiel != null && !nom_referentiel.equals("")) { |
| intervention.setReferentiel(nom_referentiel); |
| } |
| |
| if (!idParent.equals("")) { |
| intervention.setIdParent(idParent); |
| } |
| |
| if (jsonIntervention.get("votes") != null && jsonIntervention.get("votes").isObject() != null) { |
| intervention.setVotesDeterminations(parserVotesDetermination(jsonIntervention.get("votes").isObject())); |
| } |
| |
| intervention.setDate(date); |
| interventionsNonTypees.put(intervention.getId(), intervention); |
| |
| } else { |
| Commentaire intervention = new Commentaire(contributeur, date, texte); |
| intervention.setId(id); |
| intervention.setDate(date); |
| interventionsNonTypees.put(intervention.getId(), intervention); |
| if (!idParent.equals("")) { |
| intervention.setIdParent(idParent); |
| } |
| } |
| } |
| |
| Iterator<String> itIntervention = interventionsNonTypees.keySet().iterator(); |
| while (itIntervention.hasNext()) { |
| String id = itIntervention.next(); |
| InterventionForum intervention = interventionsNonTypees.get(id); |
| String idParent = intervention.getIdParent(); |
| if (idParent != null && !idParent.equals("") && !idParent.equals("0") && interventionsNonTypees.containsKey(idParent)) { |
| InterventionForum parent = interventionsNonTypees.get(idParent); |
| intervention.setParent(parent); |
| parent.ajouterCommentaire((Commentaire) intervention); |
| } else { |
| retour.add(intervention); |
| } |
| } |
| |
| 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) { |
| id = getValeurOuVide(retour, "id_commentaire"); |
| } |
| return id; |
| } |
| |
| public static String getValeurOuVide(JSONObject objet, String index) { |
| return (objet.get(index) != null && objet.get(index).isString() != null) ? objet.get(index).isString().stringValue() : ""; |
| } |
| |
| /** |
| * 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; |
| |
| JSONObject votes = JSONParser.parseStrict(votesString).isObject(); |
| if (votes != null && votes.get("resultats") != null && votes.get("resultats").isObject() != null) { |
| JSONObject resultat = votes.get("resultats").isObject(); |
| retour = parserVotesDetermination(resultat); |
| } |
| 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(); |
| while (itVotes.hasNext()) { |
| JSONObject vote = votes.get(itVotes.next()).isObject(); |
| VoteDetermination vd = new VoteDetermination(); |
| vd.setContributeur(getValeurOuVide(vote, "auteur.id")); |
| vd.setDate(parserDateObservation(getValeurOuVide(vote, "date"))); |
| vd.setId(getValeurOuVide(vote, "vote.id")); |
| vd.setVote(Integer.parseInt(getValeurOuVide(vote, "vote"))); |
| vd.setContributeur(getValeurOuVide(vote, "auteur.id")); |
| |
| if (vote.get("auteur.nom") != null && vote.get("auteur.nom") != null && vote.get("auteur.courriel") != null) { |
| Contributeur auteur = new Contributeur(getValeurOuVide(vote, "auteur.id"), getValeurOuVide(vote, "auteur.nom"), getValeurOuVide(vote, "auteur.prenom"), getValeurOuVide(vote, "auteur.courriel")); |
| vd.setAuteur(auteur); |
| } |
| |
| votesDetermination.put(getValeurOuVide(vote, "auteur.id"), vd); |
| } |
| 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>>(); |
| java.util.Iterator<String> itProtocoles = votes.keySet().iterator(); |
| while (itProtocoles.hasNext()) { |
| JSONObject protocole = votes.get(itProtocoles.next()).isObject(); |
| JSONObject votesPourCeProtocoles = protocole.get("votes").isObject(); |
| String idProtocoleVote = protocole.get("protocole.id").isString().stringValue(); |
| java.util.Iterator<String> itVotes = votesPourCeProtocoles.keySet().iterator(); |
| while (itVotes.hasNext()) { |
| JSONObject voteEnCours = votesPourCeProtocoles.get(itVotes.next()).isObject(); |
| VoteProtocole vd = new VoteProtocole(); |
| vd.setContributeur(voteEnCours.get("auteur.id").isString().stringValue()); |
| vd.setId(voteEnCours.get("vote.id").isString().stringValue()); |
| // TODO récupérer la date du vote et la parser |
| vd.setDate(parserDateObservation(getValeurOuVide(voteEnCours, "date"))); |
| int valeurVote = Integer.parseInt(voteEnCours.get("vote").isString().stringValue()); |
| vd.setVote(valeurVote); |
| if (!votesProtocoles.containsKey(idProtocoleVote)) { |
| votesProtocoles.put(idProtocoleVote, new HashMap<String, VoteProtocole>()); |
| } |
| // un seul vote par utilisateur - garde le premier pour être cohérent avec commun/Stats (PHP) |
| if (! votesProtocoles.get(idProtocoleVote).containsKey(vd.getContributeur())) { |
| votesProtocoles.get(idProtocoleVote).put(vd.getContributeur(), vd); |
| } |
| } |
| } |
| |
| 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"); |
| try { |
| dateParsee = formatDateObs.parse(date); |
| } catch (IllegalArgumentException e) { |
| dateParsee = new java.sql.Date(0); |
| } |
| 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>(); |
| for (int i = 0; i < tabMotsCle.length; i++) { |
| motsClesParses.add(tabMotsCle[i].trim()); |
| } |
| |
| return motsClesParses; |
| } |
| |
| public static String getIdAvecPadding(String id) { |
| int maxZeros = 9 - id.length(); |
| for (int i = 0; i < maxZeros; i++) { |
| id = "0" + id; |
| } |
| return id; |
| } |
| |
| /** |
| * Recupere un utilisateur à partir du JSON |
| * |
| * @param imageJson |
| * @return |
| */ |
| public static Utilisateur parserUtilisateurJson(JSONValue valeurJson) { |
| JSONObject utilisateurJson = valeurJson.isObject(); |
| boolean connecteUtilisateur = utilisateurJson.get("connecte").isBoolean().booleanValue(); |
| String idUtilisateur = utilisateurJson.get("id_utilisateur").isString().stringValue(); |
| String sessionId = utilisateurJson.get("session_id").isString().stringValue(); |
| GWT.log(valeurJson.toString()); |
| |
| Utilisateur utilisateur; |
| if (connecteUtilisateur) { |
| String courrielUtilisateur = utilisateurJson.get("courriel").isString().stringValue(); |
| String nomUtilisateur = utilisateurJson.get("nom").isString().stringValue(); |
| String prenomUtilisateur = utilisateurJson.get("prenom").isString().stringValue(); |
| |
| String adminNiveau = ""; |
| if (utilisateurJson.get("admin").isString() != null) { |
| adminNiveau = utilisateurJson.get("admin").isString().stringValue(); |
| } |
| |
| //String nbEvtsUtilisateur = utilisateurJson.get("nb_evenements").isString().stringValue(); |
| String dateDerniereConsultationEvts = utilisateurJson.get("date_derniere_consultation_evenements").isString().stringValue(); |
| |
| utilisateur = new Utilisateur(sessionId, idUtilisateur, prenomUtilisateur, nomUtilisateur, |
| courrielUtilisateur, adminNiveau); |
| |
| ActiviteUtilisateur activite = new ActiviteUtilisateur(); |
| //activite.setNbEvenements(nbEvtsUtilisateur); |
| activite.setDateDerniereConsultationEvenements(dateDerniereConsultationEvts); |
| |
| utilisateur.setActivite(activite); |
| } else { |
| utilisateur = new Utilisateur(sessionId, idUtilisateur); |
| } |
| return utilisateur; |
| } |
| |
| /** |
| * Recupere des informations d'authentification à partir du JSON renvoyé par les |
| * services Auth de l'annuaire (SSO) |
| * |
| * @param valeurJson |
| * @return AuthInfo |
| */ |
| public static AuthInfo parserAuthJson(JSONValue valeurJson) { |
| AuthInfo authInfo = new AuthInfo(); |
| JSONObject authJson = valeurJson.isObject(); |
| |
| JSONValue erreurJSON = authJson.get("error"); |
| // test si erreur |
| if (erreurJSON != null) { |
| JSONString erreur = erreurJSON.isString(); |
| if (erreur != null) { |
| authInfo.error = erreur.stringValue(); |
| } else { |
| authInfo.error = "erreur d'authentification"; |
| } |
| } else { |
| boolean session = authJson.get("session").isBoolean().booleanValue(); |
| authInfo.session = session; |
| // test si session ouverte |
| if (session) { |
| JSONValue tokenJson = authJson.get("token"); |
| String token = null; |
| // protection paranoïaque |
| if (tokenJson != null) { |
| JSONString tokenString = tokenJson.isString(); |
| if (tokenString != null) { |
| token = tokenString.stringValue(); |
| } |
| } |
| String tokenId = authJson.get("token_id").isString().stringValue(); |
| int duration = (int) authJson.get("duration").isNumber().doubleValue(); |
| JSONValue lastModifJson = authJson.get("last_modif"); |
| |
| authInfo.token = token; |
| authInfo.tokenId = tokenId; |
| authInfo.duration = duration; |
| // test si lastModif est null |
| if (lastModifJson != null) { |
| JSONNumber lastModif = lastModifJson.isNumber(); |
| if (lastModif != null) { |
| authInfo.lastModif = (int) lastModif.doubleValue(); |
| } |
| } |
| } |
| } |
| //GWT.log(valeurJson.toString()); |
| |
| return authInfo; |
| } |
| |
| /** |
| * Recupere un utilisateur à partir du JSON |
| * |
| * @param imageJson |
| * @return |
| */ |
| public static HashMap<String, String> parserPreferencesUtilisateur(JSONValue valeurJson) { |
| |
| JSONObject utilisateurJson = valeurJson.isObject(); |
| HashMap<String, String> preferences = new HashMap<String, String>(); |
| JSONObject preferencesJson = utilisateurJson.get("preferences").isObject(); |
| |
| java.util.Iterator<String> it = preferencesJson.keySet().iterator(); |
| while (it.hasNext()) { |
| String cle = it.next(); |
| preferences.put(cle, preferencesJson.get(cle).isString().stringValue()); |
| } |
| return preferences; |
| } |
| |
| /** |
| * 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)); |
| String doitEtreIdentifiePourVoter = UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.identifie"); |
| boolean boolDoitEtreIdentifie = doitEtreIdentifiePourVoter.equals("1") ? true : false; |
| protocole.setDoitEtreIdentifiePourVoter(boolDoitEtreIdentifie); |
| protocole.setNom(UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.intitule")); |
| protocole.setDescription(UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.descriptif")); |
| protocole.setTag(UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.tag")); |
| protocole.setMotsClesProtocole(UtilitairesServiceResultat.getValeurOuVide(protocoleJSON, "protocole.mots_cles")); |
| 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; |
| // ATTENTION : "resultats" devrait contenir un array car il garantit l'ordre ce qui est important pour |
| // résultat de recherche. Migration progressive des ws pour qu'ils retourne un array et non un objet. |
| if (retourJson.isObject().get("resultats").isObject() != null) { |
| // TODO : supprimer cette condition quand tous les ws seront migrés vers array. |
| JSONObject tableauImg = retourJson.isObject().get("resultats").isObject(); |
| if (tableauImg != null) { |
| 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 if (retourJson.isObject().get("resultats").isArray() != null) { |
| JSONArray tableauImg = retourJson.isObject().get("resultats").isArray(); |
| if (tableauImg != null) { |
| int nbInfosImagesRetournees = (int) tableauImg.size(); |
| for (int i = 0; i < nbInfosImagesRetournees; i++) { |
| JSONObject imageJson = tableauImg.get(i).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; |
| JSONArray tableauObs = retourJson.isObject().get("resultats").isArray(); |
| |
| if (tableauObs != null) { |
| for(int i = 0; i < tableauObs.size(); i++) { |
| JSONObject observationJson = tableauObs.get(i).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; |
| } |
| |
| public static List<MotCle> parserRetourListeMotsClesImage(JSONObject retourJson) { |
| List<MotCle> motsCles = new ArrayList<MotCle>(); |
| JSONObject tableauMc = retourJson; |
| if (tableauMc != null) { |
| java.util.Iterator<String> it = tableauMc.keySet().iterator(); |
| while (it.hasNext()) { |
| JSONObject mc = tableauMc.get(it.next()).isObject(); |
| MotCle motCle = new MotCle(getValeurOuVide(mc, "id_mot_cle"), getValeurOuVide(mc, "image"), getValeurOuVide(mc, "mot_cle")); |
| motsCles.add(motCle); |
| } |
| } |
| return motsCles; |
| } |
| |
| public static String parserRetourAjoutVoteProtocole(JSONObject retour) { |
| String id = ""; |
| if (retour != null) { |
| id = getValeurOuVide(retour, "id_vote"); |
| } |
| return id; |
| } |
| |
| public static Map<String, String> parserListePays(JSONValue retourJson) { |
| Map<String, String> listePays = new LinkedHashMap<String, String>(); |
| JSONArray tableauPays = retourJson.isArray(); |
| int nbPays = (int) tableauPays.size(); |
| for (int i = 0; i < nbPays; i++) { |
| JSONObject pays = tableauPays.get(i).isObject(); |
| listePays.put(pays.get("code_iso_3166_1").isString().stringValue(), pays.get("nom_fr").isString().stringValue()); |
| } |
| return listePays; |
| } |
| |
| public static ActiviteUtilisateur parserActiviteUtilisateurJson(JSONValue valeurJson) { |
| |
| JSONObject activiteJson = valeurJson.isObject(); |
| |
| //String nbEvtsUtilisateur = activiteJson.get("nb_evenements").isString().stringValue(); |
| String dateDerniereConsultationEvts = activiteJson.get("date_derniere_consultation_evenements").isString().stringValue(); |
| |
| ActiviteUtilisateur activite = new ActiviteUtilisateur(); |
| //activite.setNbEvenements(nbEvtsUtilisateur); |
| activite.setDateDerniereConsultationEvenements(dateDerniereConsultationEvts); |
| |
| return activite; |
| } |
| } |