Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.vues.identiplante.plateformedetermination;

import java.util.List;

import org.tela_botanica.del.client.cache.CacheClient;
import org.tela_botanica.del.client.composants.fenetreoverlay.FenetreOverlayDefilanteVue;
import org.tela_botanica.del.client.composants.fenetreoverlay.FenetreOverlaySimplePresenteur;
import org.tela_botanica.del.client.composants.formulaires.formulairecommentaire.FormulaireCommentairePresenteur;
import org.tela_botanica.del.client.composants.formulaires.formulairecommentaire.FormulaireCommentaireVue;
import org.tela_botanica.del.client.composants.formulaires.formulaireproposition.FormulairePropositionPresenteur;
import org.tela_botanica.del.client.composants.formulaires.formulaireproposition.FormulairePropositionVue;
import org.tela_botanica.del.client.composants.metadonnees.MetadonneesEnLigneVue;
import org.tela_botanica.del.client.composants.metadonnees.MetadonneesPresenteur;
import org.tela_botanica.del.client.composants.observations.ObservationImagesPresenteur;
import org.tela_botanica.del.client.composants.observations.ObservationImagesVue;
import org.tela_botanica.del.client.composants.presenteur.Presenteur;
import org.tela_botanica.del.client.composants.rss.RssPresenteur;
import org.tela_botanica.del.client.composants.rss.RssVue;
import org.tela_botanica.del.client.config.Config;
import org.tela_botanica.del.client.i18n.I18n;
import org.tela_botanica.del.client.modeles.Image;
import org.tela_botanica.del.client.modeles.ModeRecherche;
import org.tela_botanica.del.client.modeles.MoyenneVote;
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.Utilisateur;
import org.tela_botanica.del.client.modeles.VoteDetermination;
import org.tela_botanica.del.client.navigation.evenement.BusEvenementiel;
import org.tela_botanica.del.client.navigation.evenement.ajoutcommentaire.EvenementAjoutCommentaire;
import org.tela_botanica.del.client.navigation.evenement.ajoutcommentaire.GestionnaireEvenementAjoutCommentaire;
import org.tela_botanica.del.client.navigation.evenement.ajoutdetermination.EvenementAjoutDetermination;
import org.tela_botanica.del.client.navigation.evenement.ajoutdetermination.GestionnaireEvenementAjoutDetermination;
import org.tela_botanica.del.client.navigation.evenement.changementEtatUtilisateur.EvenementChangementEtatUtilisateur;
import org.tela_botanica.del.client.navigation.evenement.changementEtatUtilisateur.GestionnaireEvenementChangementEtatUtilisateur;
import org.tela_botanica.del.client.navigation.evenement.changementimagevalidation.EvenementChangementImageValidation;
import org.tela_botanica.del.client.navigation.evenement.changementimagevalidation.GestionnaireEvenementChangementImageValidation;
import org.tela_botanica.del.client.navigation.evenement.depublierObs.EvenementDepublierObs;
import org.tela_botanica.del.client.navigation.evenement.depublierObs.GestionnaireEvenementDepublierObs;
import org.tela_botanica.del.client.navigation.evenement.voteDetermination.EvenementVoteDetermination;
import org.tela_botanica.del.client.navigation.evenement.voteDetermination.GestionnaireEvenementVoteDetermination;
import org.tela_botanica.del.client.services.CalculVoteDeterminationService;
import org.tela_botanica.del.client.services.rest.CommentaireServiceConcret;
import org.tela_botanica.del.client.services.rest.ObservationService;
import org.tela_botanica.del.client.services.rest.PropositionDeterminationServiceConcret;
import org.tela_botanica.del.client.services.rest.async.DepublicationObservationCallBack;
import org.tela_botanica.del.client.services.rest.async.ObservationsCallback;
import org.tela_botanica.del.client.services.rest.async.ValidationPropositionCallback;
import org.tela_botanica.del.client.utils.URLUtils;
import org.tela_botanica.del.client.navigation.evenement.rechercheobservation.EvenementRechercheObservation;
import org.tela_botanica.del.client.composants.formulairerechercheeflore.FormulaireRechercheEflorePresenteur;
import org.tela_botanica.del.client.composants.forum.ForumPresenteur;
import org.tela_botanica.del.client.composants.forum.ForumVue;

import com.google.gwt.core.shared.GWT;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.HasClickHandlers;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.IsWidget;
import com.google.gwt.user.client.ui.Panel;

public class IdentiplanteDeterminationPresenteur extends Presenteur {

        /**
         * Vue de l'interface de détermination
         * */
        public interface Vue extends IsWidget {
                public Panel getForum();

                public Panel getDetailImageObservation();

                public Panel getFormulaireRechercheEflore();

                public Button getBoutonAjoutProposition();

                public Button getBoutonAjoutCommentaire();

                public Button getBoutonAjoutPropositionBas();

                public Button getBoutonAjoutCommentaireBas();
                
                public HasClickHandlers getBoutonDepublierObs();

                public HasWidgets getMetadonnees();

                public void afficherNomTaxonProbable(String nomTaxon);
                
                public HasClickHandlers getLienOuvrages();
                
                public HasClickHandlers getLienBonnier();
                
                public HasClickHandlers getLienCles();
                
                public HasClickHandlers getLienEflore();
        
                public HasWidgets getZoneRss();

                HasClickHandlers getBoutonValidationTaxon();

                void cacherBoutonValidationTaxon();

                void afficherBoutonValidationTaxon();

                public void viderMetadonnees();
                
                void afficherZoneActionsObs();
                
                void cacherZoneActionsObs();
        }

        private Observation observation;
        private Vue vue;
        private FenetreOverlaySimplePresenteur fenetreOverlaySimplePresenteur;

        // Déclaration des services à utiliser
        private ObservationService observationService;

        private CacheClient cache = CacheClient.getInstance();
        
        private PropositionDetermination propositionPlusPopulaire;

        public IdentiplanteDeterminationPresenteur(Vue vue, ObservationService observationService) {
                this.vue = vue;
                this.observationService = observationService;
        }

        public void go(final HasWidgets composite) {
                // TODO afficher une icone de chargement si le chargement devient trop
                // long
                // car tout l'écran est asynchrone ici
                String observationId = URLUtils.getURLSpecialParameterValue();
                observationService.getObservation(observationId, new ObservationsCallback() {
                        @Override
                        public void surRetour(ObservationServiceResultat objetRetour) {
                                observation = cache.getObservationCourante();
                                afficherRss(cache.getObservationCourante());
                                // trouve l'image courante si elle n'est pas deja en cache
                                List<Image> listeImages = cache.getObservationCourante().getImages();
                                if (listeImages.size() > 0) {
                                        CacheClient.getInstance().setImageCourante(listeImages.get(0));
                                } else {
                                        CacheClient.getInstance().setImageCourante(null);
                                }
                                
                                new MetadonneesPresenteur(new MetadonneesEnLigneVue(), cache.getObservationCourante(), ModeRecherche.MODE_OBSERVATION, false).go(vue.getMetadonnees());
                                new ObservationImagesPresenteur(new ObservationImagesVue(), cache.getObservationCourante(), CacheClient.getInstance().getImageCourante()).go(vue.getDetailImageObservation());
                                new ForumPresenteur(new ForumVue()).go(vue.getForum());
                                new FormulaireRechercheEflorePresenteur().go(vue.getFormulaireRechercheEflore());

                                composite.add(vue.asWidget());
                                calculerEtAfficherVoteDeterminationPlusPopulaire();
                        }

                        @Override
                        public void surErreur(String messageErreur) {
                                Window.alert(messageErreur + " - l'identifiant d'observation est incorrect; l'observation a peut-être été supprimée");
                        }
                });
                afficherZoneActionsObs();
                gererEvenements();
        }

        public void afficherRss(Observation observation) {
                new RssPresenteur(new RssVue(), observation, "Suivre cette observation").go(vue.getZoneRss());
        }

        private void calculerEtAfficherVoteDeterminationPlusPopulaire() {
                if (cache.getObservationCourante() != null) {
                        Observation observation = cache.getObservationCourante();
                        String nomTaxon = observation.getNomRetenuFormateReferentiel();
                        List<MoyenneVote> votesOrdonnes = CalculVoteDeterminationService.calculerVoteDeterminationPlusPopulaire(cache.getObservationCourante().getPropositionDeterminations());
                        if (votesOrdonnes.size() > 0) {
                                nomTaxon = votesOrdonnes.get(0).getIntituleAssocie();
                                propositionPlusPopulaire = votesOrdonnes.get(0).getPropositionAssociee();
                                
                                if (doitAfficherBoutonValidation(votesOrdonnes)) {
                                        vue.afficherBoutonValidationTaxon();
                                } else {
                                        vue.cacherBoutonValidationTaxon();
                                }
                        }
                        vue.afficherNomTaxonProbable(nomTaxon);
                }
        }
        
        private boolean doitAfficherBoutonValidation(List<MoyenneVote> votesOrdonnes) {         
                boolean estPropositionRetenue = votesOrdonnes.get(0).getPropositionAssociee().estPropositionRetenue();
                
                Utilisateur utilisateur = CacheClient.getInstance().getUtilisateur();
                boolean estAuteurObservation = false;
                if(utilisateur != null) {
                        estAuteurObservation = utilisateur.estIdentifie() && utilisateur.getId().equals(cache.getObservationCourante().getIdAuteur());
                }
                return estAuteurObservation && !estPropositionRetenue;
        }

        public void gererEvenements() {
                BusEvenementiel.getInstance().addHandler(EvenementChangementEtatUtilisateur.TYPE, new GestionnaireEvenementChangementEtatUtilisateur() {
                        @Override
                        public void onModificationEtatUtilisateur(EvenementChangementEtatUtilisateur evenementChangementEtatUtilisateur) {
                                calculerEtAfficherVoteDeterminationPlusPopulaire();
                        };
                });
                
                BusEvenementiel.getInstance().addHandler(EvenementVoteDetermination.TYPE, new GestionnaireEvenementVoteDetermination() {
                        @Override
                        public void onVoteDetermination(VoteDetermination event) {
                                calculerEtAfficherVoteDeterminationPlusPopulaire();
                        }
                });
                
                BusEvenementiel.getInstance().addHandler(EvenementAjoutDetermination.TYPE, new GestionnaireEvenementAjoutDetermination() {
                        @Override
                        public void onAjoutDetermination(EvenementAjoutDetermination event) {
                                if (fenetreOverlaySimplePresenteur != null && fenetreOverlaySimplePresenteur.fenetreModaleEstOuverte()) {
                                        fenetreOverlaySimplePresenteur.fermerFenetreModale();
                                }
                        }
                });

                BusEvenementiel.getInstance().addHandler(EvenementAjoutCommentaire.TYPE, new GestionnaireEvenementAjoutCommentaire() {
                        @Override
                        public void onAjoutCommentaire(EvenementAjoutCommentaire event) {
                                if (fenetreOverlaySimplePresenteur != null && fenetreOverlaySimplePresenteur.fenetreModaleEstOuverte()) {
                                        fenetreOverlaySimplePresenteur.fermerFenetreModale();
                                }
                        }
                });

                BusEvenementiel.getInstance().addHandler(EvenementChangementImageValidation.TYPE, new GestionnaireEvenementChangementImageValidation() {
                        @Override
                        public void onChangementImage(EvenementChangementImageValidation event) {
                                vue.getDetailImageObservation().clear();
                                new ObservationImagesPresenteur(
                                        new ObservationImagesVue(), 
                                        cache.getObservationCourante(), 
                                        CacheClient.getInstance().getImageCourante()).go(vue.getDetailImageObservation());
                        }
                });

                ClickHandler clicAjoutProposition = new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                fenetreOverlaySimplePresenteur = new FenetreOverlaySimplePresenteur(new FenetreOverlayDefilanteVue());
                                fenetreOverlaySimplePresenteur.ouvrirFenetreModale(new FormulairePropositionPresenteur(new FormulairePropositionVue(), new PropositionDeterminationServiceConcret()));
                        }
                };
                vue.getBoutonAjoutProposition().addClickHandler(clicAjoutProposition);
                vue.getBoutonAjoutPropositionBas().addClickHandler(clicAjoutProposition);

                ClickHandler clicAjoutCommentaire = new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                FormulaireCommentairePresenteur commentairePresenteur = new FormulaireCommentairePresenteur(cache.getObservationCourante(), new CommentaireServiceConcret(), new FormulaireCommentaireVue());
                                fenetreOverlaySimplePresenteur = new FenetreOverlaySimplePresenteur(new FenetreOverlayDefilanteVue());
                                fenetreOverlaySimplePresenteur.ouvrirFenetreModale(commentairePresenteur);
                        }
                };
                vue.getBoutonAjoutCommentaire().addClickHandler(clicAjoutCommentaire);
                vue.getBoutonAjoutCommentaireBas().addClickHandler(clicAjoutCommentaire);

                vue.getLienOuvrages().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                Config config = new Config();
                                Window.open(config.getUrl("ouvragesFlore"), "Flores numérisées", config.getInfo("popupOptions"));
                        }
                });

                vue.getLienBonnier().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                Config config = new Config();
                                Window.open(config.getUrl("bonnierPda"), "Flore Bonnier PDA", config.getInfo("popupOptions"));
                        }
                });
                
                vue.getLienCles().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                Config config = new Config();
                                Window.open(config.getUrl("clesDetermination"), "Clés de determination", config.getInfo("popupOptions"));
                        }
                });
                
                vue.getLienEflore().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                Config config = new Config();
                                Window.open(config.getUrl("eflore"), "eFlore", config.getInfo("popupOptions"));
                        }
                });
                
                vue.getBoutonValidationTaxon().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                if (Window.confirm(I18n.getVocabulary().confirmationValidationDetermination())) {
                                        validerPropositionPlusPopulaire();
                                }
                        }
                });
                
                vue.getBoutonDepublierObs().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {
                                GWT.log("Lancer evnt : EvenementDepublierObs");
                                if (Window.confirm(I18n.getVocabulary().confirmationDepublicationObs())) {
                                        BusEvenementiel.getInstance().fireEvent(new EvenementDepublierObs(observation.getId()));
                                }
                        }
                });
                
                BusEvenementiel.getInstance().addHandler(EvenementDepublierObs.TYPE, new GestionnaireEvenementDepublierObs() {
                        @Override
                        public void onDepublicationObs(EvenementDepublierObs event) {
                                GWT.log("Attraper evnt : EvenementDepublierObs (obs:"+event.getIdObs()+")");
                                if (event.getIdObs().equals(observation.getId())) {
                                        depublierObs();
                                }
                        }
                });
                
                BusEvenementiel.getInstance().addHandler(EvenementChangementEtatUtilisateur.TYPE, new GestionnaireEvenementChangementEtatUtilisateur() {
                        @Override
                        public void onModificationEtatUtilisateur(EvenementChangementEtatUtilisateur evenementChangementEtatUtilisateur) {
                                afficherZoneActionsObs();
                        }
                });
        }
        
        private void validerPropositionPlusPopulaire() {
                PropositionDeterminationServiceConcret propositionService = new PropositionDeterminationServiceConcret();
                propositionService.validerProposition(propositionPlusPopulaire, new ValidationPropositionCallback() {
                        @Override
                        public void surRetour(String objetRetour) {
                                String observationId = URLUtils.getURLSpecialParameterValue();
                                observationService.getObservation(observationId, new ObservationsCallback() {

                                        @Override
                                        public void surRetour(ObservationServiceResultat objetRetour) {
                                                vue.viderMetadonnees();
                                                new MetadonneesPresenteur(new MetadonneesEnLigneVue(), cache.getObservationCourante(), ModeRecherche.MODE_OBSERVATION, false).go(vue.getMetadonnees());
                                                calculerEtAfficherVoteDeterminationPlusPopulaire();
                                        }

                                        @Override
                                        public void surErreur(String messageErreur) {
                                                Window.alert(messageErreur);
                                        }
                                });
                        }
                });
        }
        
        private void depublierObs() {
                if (avoirUtilisateurAdmin()) {
                        GWT.log("depublierObs :"+observation.getId());
                        observationService.depublier(observation, new DepublicationObservationCallBack() {
                                
                                @Override
                                public void surRetour(String depublicationOk) {
                                        GWT.log("Dépublication obs "+observation.getId()+" "+depublicationOk);
                                        if (depublicationOk.equals("OK")) {
                                                BusEvenementiel.getInstance().fireEvent(new EvenementRechercheObservation());
                                        }
                                }
                        });
                }
        }
        
        private void afficherZoneActionsObs() {
                if (avoirUtilisateurAdmin()) {
                        vue.afficherZoneActionsObs();
                } else {
                        vue.cacherZoneActionsObs();
                }
        }
        
        private boolean avoirUtilisateurAdmin() {
                Utilisateur utilisateur = CacheClient.getInstance().getUtilisateur();
                boolean etreAdmin = false;
                if (utilisateur != null) {
                        etreAdmin = utilisateur.estIdentifie() && utilisateur.etreAdmin();
                }
                return etreAdmin;
        }
}