Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.vues.rechercheimages.moteur;

import org.tela_botanica.del.client.cache.CacheClient;
import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur;
import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRechercheVue;
import org.tela_botanica.del.client.modeles.ModeRecherche;
import org.tela_botanica.del.client.modeles.ProtocoleServiceResultat;
import org.tela_botanica.del.client.services.rest.ImageServiceConcret;
import org.tela_botanica.del.client.services.rest.ProtocoleService;
import org.tela_botanica.del.client.services.rest.ProtocoleServiceConcret;
import org.tela_botanica.del.client.services.rest.async.ProtocolesCallback;
import org.tela_botanica.del.client.vues.rechercheimages.resultats.ResultatRechercheImagePresenteur;
import org.tela_botanica.del.client.vues.rechercheimages.resultats.ResultatRechercheImageVue;

import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.IsWidget;

public class MoteurRechercheImagePresenteur {

        public interface Vue extends IsWidget {
                public HasWidgets getZoneResultats();

                public HasWidgets getZoneRecherche();

                public void ajouterVue(HasWidgets composite);
        }

        private Vue vue;
        private final ProtocoleService protocoleService = new ProtocoleServiceConcret();

        /**
         * Constructeur
         * */
        public MoteurRechercheImagePresenteur(Vue vue) {
                this.vue = vue;
                // TODO: le code ci dessous sert à ne pas recharger les protocoles
                // à chaque fois, voir si on peut le factoriser quelque part
                if (CacheClient.getInstance().getProtocoleCourant() == null) {
                        if (CacheClient.getInstance().getListeProtocoles() == null) {
                                protocoleService.getProtocoles(new ProtocolesCallback() {

                                        @Override
                                        public void surRetour(ProtocoleServiceResultat protocolesRecus) {
                                                CacheClient.getInstance().setListeProtocoles(protocolesRecus.getProtocoles());
                                                if (protocolesRecus.getProtocoles().size() > 0) {
                                                        CacheClient.getInstance().setProtocoleCourant(protocolesRecus.getProtocoles().get(0));
                                                } else {
                                                        // TODO afficher message indiquant que la liste des
                                                        // protocoles de votes n'est pas fourni
                                                }
                                        }
                                });
                        } else {
                                CacheClient.getInstance().setProtocoleCourant(CacheClient.getInstance().getListeProtocoles().get(0));
                        }
                }
        }

        public void go(HasWidgets composite) {
                vue.ajouterVue(composite);
                chargerMoteurRechercheAvancee();
        }

        public void chargerMoteurRechercheAvancee() {
                MoteurRecherchePresenteur presenteurRecherche = new MoteurRecherchePresenteur(new MoteurRechercheVue(""), ModeRecherche.MODE_IMAGE) {
                        public void lancerRecherche() {
                                chercherImages();
                        }
                };
                presenteurRecherche.go(vue.getZoneRecherche());
        }

        public void chercherImages() {
                vue.getZoneResultats().clear();
                new ResultatRechercheImagePresenteur(new ImageServiceConcret(), new ResultatRechercheImageVue()).go(vue.getZoneResultats());
        }

        public HasWidgets getZoneResultats() {
                return vue.getZoneResultats();
        }
}