Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.composants.formulaires.formulaireproposition;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.tela_botanica.del.client.cache.CacheClient;
import org.tela_botanica.del.client.composants.formulaires.autocompletion.AutoCompletionComboBoxPresenteur;
import org.tela_botanica.del.client.composants.formulaires.autocompletion.AutoCompletionComboBoxVue;
import org.tela_botanica.del.client.composants.presenteur.Presenteur;
import org.tela_botanica.del.client.composants.validation.ValidateurChampTexteNonNul;
import org.tela_botanica.del.client.config.Config;
import org.tela_botanica.del.client.i18n.I18n;
import org.tela_botanica.del.client.modeles.Contributeur;
import org.tela_botanica.del.client.modeles.InterventionForum;
import org.tela_botanica.del.client.modeles.PropositionDetermination;
import org.tela_botanica.del.client.modeles.Utilisateur;
import org.tela_botanica.del.client.navigation.evenement.BusEvenementiel;
import org.tela_botanica.del.client.navigation.evenement.ajoutdetermination.EvenementAjoutDetermination;
import org.tela_botanica.del.client.services.ReferentielService;
import org.tela_botanica.del.client.services.rest.PropositionDeterminationService;
import org.tela_botanica.del.client.services.rest.async.PropositionDeterminationCallBack;
import org.tela_botanica.del.client.utils.InfosNomPourAutocompletion;
import org.tela_botanica.del.client.utils.UtilitairesAutoCompletionService;

import com.google.gwt.core.client.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.http.client.Response;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HasText;
import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.IsWidget;

public class FormulairePropositionPresenteur extends Presenteur {

        public interface Vue extends IsWidget {
                public HasText getObjetNom();

                public HasText getObjetPrenom();

                public HasWidgets getPropositionTaxon();

                public HasText getCommentaires();

                public HasClickHandlers getBoutonValidationProposition();

                public void afficherNomPrenomEtDesactiver(String nom, String prenom);

                public String getCourriel();

                public void afficherEmailEtDesactiver(String courriel);

                public String getNom();

                public String getPrenom();

                public void afficherStyleErreurNom(String styleErreur);

                public void supprimerStyleErreurNom(String styleErreur);

                public void afficherStyleErreurPrenom(String styleErreur);

                public void supprimerStyleErreurPrenom(String styleErreur);
                
                public void afficherPropositionDejaEffectuée(String taxon);

                public HasText getObjetCourriel();
                
                public void setReferentiel(String referentiel);
                
                public String getReferentiel();

                public void afficherStyleErreurCourriel(String styleErreur);

                void supprimerStyleErreurCourriel(String styleErreur);

                void remplirListeReferentiels(Map<String, String> listeReferentiels);
        }

        private Vue vue;
        private Config config;
        private AutoCompletionComboBoxPresenteur autoCompletionNomTaxonsPresenteur;
        private PropositionDeterminationService propositionDeterminationService;
        
        private Map<String, InfosNomPourAutocompletion> cacheTaxons = new HashMap<String, InfosNomPourAutocompletion>();

        public FormulairePropositionPresenteur(Vue vue, PropositionDeterminationService propositionDeterminationService) {
                this.vue = vue;
                this.propositionDeterminationService=propositionDeterminationService;
                config = new Config();
                creerCompletionTaxons();
                remplirAvecInfosUtilisateur();
        }

        private void remplirAvecInfosUtilisateur() {
                Utilisateur utilisateur = CacheClient.getInstance().getUtilisateur();
                if (utilisateur.estIdentifie()) {
                        vue.afficherNomPrenomEtDesactiver(utilisateur.getNom(), utilisateur.getPrenom());
                        vue.afficherEmailEtDesactiver(utilisateur.getCourriel());
                }
        }

        private void creerCompletionTaxons() {
                String url = this.config.getServiceBaseUrl() + "nomstaxons";
                vue.remplirListeReferentiels(ReferentielService.getReferentiels());
                final String referentiel = CacheClient.getInstance().getObservationCourante().getReferentiel();

                // découpage pseudo-intelligent du nom de référentiel
                String referentielPredefini;
                int positionDeuxPoints = referentiel.indexOf(':');
                if (positionDeuxPoints == -1) {
                        referentielPredefini = referentiel;
                } else {
                        referentielPredefini = referentiel.substring(0, positionDeuxPoints);
                }
                
                if (referentielPredefini.equals("autre") || referentielPredefini.equals("")) {
                        referentielPredefini = "bdtfx"; // évite de saisir des noms latins en dur et de perdre le nn
                }
                vue.setReferentiel(referentielPredefini);
                autoCompletionNomTaxonsPresenteur = new AutoCompletionComboBoxPresenteur(new AutoCompletionComboBoxVue(), url) {
                        protected String effectuerPreTraitementChaineRequete(String requete) {          
                                // si aucun référentiel selectionné, pas de requete
                                if(vue.getReferentiel() != null && !vue.getReferentiel().equals("") && !vue.getReferentiel().equals("tous")) {
                                        // découpage pseudo-intelligent du nom de référentiel
                                        String refFmt;
                                        int positionDeuxPoints = vue.getReferentiel().indexOf(':');
                                        if (positionDeuxPoints == -1) {
                                                refFmt = vue.getReferentiel();
                                        } else {
                                                refFmt = vue.getReferentiel().substring(0, positionDeuxPoints);
                                        }
                                        requete = "?masque.nom=" + requete + "&masque.referentiel=" + refFmt;
                                        return requete;
                                } else {
                                        return null;
                                }
                        }

                        @Override
                        protected InfosNomPourAutocompletion[] parserResultatRequete(Response response) {
                                cacheTaxons = UtilitairesAutoCompletionService.extraireTaxonsNumNomsResultatRetourSimple(response);
                                return UtilitairesAutoCompletionService.parserResultatRetourSimple(response);
                        }
                };
        }

        public void go(HasWidgets composite) {
                autoCompletionNomTaxonsPresenteur.go(vue.getPropositionTaxon());
                composite.add(vue.asWidget());
                gererEvenements();
        }

        protected void gererEvenements() {
                vue.getBoutonValidationProposition().addClickHandler(new ClickHandler() {
                        @Override
                        public void onClick(ClickEvent event) {

                                if (!validerSaisieProposition()) {
                                        return;
                                } else {
                                        final PropositionDetermination propositionAjoutee = collecterValeursSaisieProposition();
                                        if(verifierPropositionDejaAjoutee(propositionAjoutee)){
                                                BusEvenementiel.getInstance().fireEvent(new EvenementAjoutDetermination(propositionAjoutee));
                                                vue.afficherPropositionDejaEffectuée(propositionAjoutee.getEspece());
                                                return;
                                        }

                                        propositionDeterminationService.ajouterProposition(propositionAjoutee, new PropositionDeterminationCallBack() {

                                                @Override
                                                public void surRetour(String idNouvelleProposition) {
                                                        propositionAjoutee.setId(idNouvelleProposition);
                                                        CacheClient.getInstance().getObservationCourante().ajouterPropositionDetermination(propositionAjoutee);
                                                        EvenementAjoutDetermination evenementAjoutDetermination = new EvenementAjoutDetermination(propositionAjoutee);
                                                        BusEvenementiel.getInstance().fireEvent(evenementAjoutDetermination);
                                                }

                                        });
                                }
                        }
                });
        }

        private boolean verifierPropositionDejaAjoutee(PropositionDetermination propositionDetermination){
                for(InterventionForum interventionForum: CacheClient.getInstance().getObservationCourante().getInterventionsForum()){
                        if(interventionForum instanceof PropositionDetermination){
                                if(((PropositionDetermination)interventionForum).getEspece().trim().equals(propositionDetermination.getEspece().trim())){
                                        return true;
                                }
                        }
                }
                return false;
        }
        
        private boolean validerSaisieProposition() {

                ValidateurChampTexteNonNul validateurNom = new ValidateurChampTexteNonNul(vue.getObjetNom()) {
                        @Override
                        public void afficherStyleErreur(String styleErreur) {
                                vue.afficherStyleErreurNom(styleErreur);
                        }

                        @Override
                        public void supprimerStyleErreur(String styleErreur) {
                                vue.supprimerStyleErreurNom(styleErreur);
                        }
                };

                ValidateurChampTexteNonNul validateurPrenom = new ValidateurChampTexteNonNul(vue.getObjetPrenom()) {
                        @Override
                        public void afficherStyleErreur(String styleErreur) {
                                vue.afficherStyleErreurPrenom(styleErreur);
                        }

                        @Override
                        public void supprimerStyleErreur(String styleErreur) {
                                vue.supprimerStyleErreurPrenom(styleErreur);
                        }
                };
                
                ValidateurChampTexteNonNul validateurCourriel = new ValidateurChampTexteNonNul(vue.getObjetCourriel()) {
                        @Override
                        public void afficherStyleErreur(String styleErreur) {
                                vue.afficherStyleErreurCourriel(styleErreur);
                        }

                        @Override
                        public void supprimerStyleErreur(String styleErreur) {
                                vue.supprimerStyleErreurCourriel(styleErreur);
                        }
                };

                ValidateurChampTexteNonNul validateurTaxon = new ValidateurChampTexteNonNul(autoCompletionNomTaxonsPresenteur.getAutoCompletionComboBoxVue().getSuggestBox()) {
                        @Override
                        public void afficherStyleErreur(String styleErreur) {
                                autoCompletionNomTaxonsPresenteur.afficherStyleErreur(styleErreur);
                        }

                        @Override
                        public void supprimerStyleErreur(String styleErreur) {
                                autoCompletionNomTaxonsPresenteur.supprimerStyleErreur(styleErreur);
                        }
                };

                boolean nomSaisi = validateurNom.valider();
                boolean prenomSaisi = validateurPrenom.valider();
                boolean courrielSaisi = validateurCourriel.valider();
                boolean taxonSaisi = validateurTaxon.valider();
                
                String taxonSaisiStr = autoCompletionNomTaxonsPresenteur.getValeur();           
                boolean utilisateurConfirme = true;
                // Si le nom est vide une erreur a déjà été déclenchée plus haut (donc pas la peine de tester cacheTaxons)
                if(!taxonSaisiStr.trim().isEmpty() && !cacheTaxons.containsKey(taxonSaisiStr.trim())) {
                        utilisateurConfirme = Window.confirm(I18n.getVocabulary().attentionPropositionTaxon());
                }

                return nomSaisi && prenomSaisi && courrielSaisi && taxonSaisi && utilisateurConfirme;
        }

        private PropositionDetermination collecterValeursSaisieProposition() {
                PropositionDetermination propositionAjoutee = new PropositionDetermination(CacheClient.getInstance().getObservationCourante());
                propositionAjoutee.setId(CacheClient.getInstance().getObservationCourante().getId());

                String idUtilisateur = null;
                if (CacheClient.getInstance().getUtilisateur().estIdentifie()) {
                        idUtilisateur = CacheClient.getInstance().getUtilisateur().getId();
                }

                Contributeur contributeur = new Contributeur(idUtilisateur, vue.getNom(), vue.getPrenom(), vue.getCourriel());
                propositionAjoutee.setContributeur(contributeur);
                propositionAjoutee.setDate(new Date());
                
                String nomTaxon = autoCompletionNomTaxonsPresenteur.getValeur();
                propositionAjoutee.setEspece(nomTaxon);
                if(cacheTaxons.containsKey(nomTaxon.trim())) {
                        propositionAjoutee.setNumNomenclatural("" + cacheTaxons.get(nomTaxon.trim()).getNn());
                }
                
                if(vue.getReferentiel() != "tous") {
                        propositionAjoutee.setReferentiel(vue.getReferentiel());
                }
                
                if (vue.getCommentaires().getText() != "") {
                        String contenuCommentaire = vue.getCommentaires().getText();
                        propositionAjoutee.setCommentaire(contenuCommentaire);
                }

                return propositionAjoutee;
        }
}