Subversion Repositories eFlore/Applications.coel

package org.tela_botanica.client.composants.pagination;

import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.Log;
import org.tela_botanica.client.util.UtilString;

import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.LoadEvent;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.google.gwt.user.client.rpc.AsyncCallback;

public class ChargeurListe<D extends PagingLoadResult<?>> extends BasePagingLoader<D> {

        private String recherche = "";
        private Rafraichissable vueARafraichir = null;
        private boolean doRafraichir = false;

        @SuppressWarnings("unchecked")
        public ChargeurListe(Proxy proxy, TransformateurJSONaModelData reader, Rafraichissable vueARafraichir) {
                super(proxy, reader);
                this.vueARafraichir = vueARafraichir;
        }
        
        public boolean load(Object loadConfig, String recherche, boolean doRafraichir) {
                this.doRafraichir = doRafraichir;
                if (fireEvent(BeforeLoad, new LoadEvent(this, loadConfig))) {
                        lastConfig = loadConfig;
                        this.recherche = recherche;
                        loadData(loadConfig, recherche);
                        return true;
                } else {
                        return false;
                }
        }
        
        public boolean load(Object loadConfig) {
                if (fireEvent(BeforeLoad, new LoadEvent(this, loadConfig))) {
                        lastConfig = loadConfig;
                        loadData(loadConfig, recherche);
                        return true;
                }
                return false;
        }
        
        public void load(int offset, int limit) {
                this.offset = offset;
                this.limit = limit;
                load();
        }
        
        public boolean load() {
                Object config = (reuseConfig && lastConfig != null) ? lastConfig : newLoadConfig();
                config = prepareLoadConfig(config);
                return load(config);
        }
        
        @SuppressWarnings("unchecked")
        protected void loadData(final Object config, String recherche) {
                AsyncCallback<D> callback = new AsyncCallback<D>() {
                        
                    public void onFailure(Throwable caught) {
                        onLoadFailure(config, caught);
                        if (!UtilString.isEmpty(caught.getMessage())) {
                                Log.error("[FAILURE] ChargeurListe : message="+caught.getMessage());
                        } else {
                                Log.error("[FAILURE] ChargeurListe : message=NULL. Peut-être le modelType est-il mal paramétré ?");
                        }
                    }
                    
                    public void onSuccess(D result) {
                        onLoadSuccess(config, result);
                        
                        /*
                        // SUPPRIMER LES PREFIXES
                        if (result instanceof BasePagingLoadResult) {
                                BasePagingLoadResult retourPaging = (BasePagingLoadResult)result;
                                List retourListe = retourPaging.getData();
                                
                                for(int i=0; i< retourListe.size(); i++) {
                                        if (retourListe.get(i) instanceof BaseModelData) {
                                                BaseModelData model = (BaseModelData)retourListe.get(i);
                                                
                                                Map<String, Object> a = model.getProperties();
                                                Set<String> cles = a.keySet();
                                                Iterator<String> it = cles.iterator();
                                                while (it.hasNext()) {
                                                        String cle = it.next();
                                                        if (a.get(cle) != null) {
                                                                String cleObjet = "";                           
                                                                cleObjet = cle.replaceFirst("^[A-Za-z]+_", "");
                                                                model.set(cleObjet, a.get(cle));
                                                                model.remove(cle);
                                                        }
                                                }
                                        }
                                }
                        }*/
                        
                        
                        // Cas où il faut rafraichir le combo manuellement
                        // (cela sert pour charger la valeur initiale du combo au chargement d'un formulaire)
                            if (doRafraichir) {
                                Information info = new Information("selectionnerValeurCombo");
                                info.setDonnee(result);
                                info.setMessage("");
                                        
                                        vueARafraichir.rafraichir(info);
                            }
                        }
                };
                ((Proxy) proxy).load((TransformateurJSONaModelData) reader, config, callback, recherche);
        }
}