Subversion Repositories eFlore/Applications.coel

package org.tela_botanica.client.composants.pagination;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.collection.CollectionAPersonne;
import org.tela_botanica.client.modeles.personne.Personne;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.UtilString;

import com.extjs.gxt.ui.client.data.BaseListLoadResult;
import com.extjs.gxt.ui.client.data.BaseModelData;
import com.extjs.gxt.ui.client.data.BasePagingLoadResult;
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())) Debug.log("[FAILURE] ChargeurListe : message="+caught.getMessage());
                      else Debug.log("[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);
        }
}