Subversion Repositories eFlore/Applications.cel

Rev

Rev 2033 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

package org.tela_botanica.client.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO;
import org.tela_botanica.client.modeles.objets.ListeChampsEtendus;
import org.tela_botanica.client.modeles.objets.ListeGroupesChampsEtendus;

import com.google.gwt.core.client.Callback;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ListenerConfig;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.Field;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.layout.FormLayout;

@SuppressWarnings("unchecked")
public abstract class FormulaireSaisieChampEtendu extends FormPanel implements Rafraichissable {
        
        private final int KEY_ALT = 18;
        private final int KEY_BACKSPACE = 8;
        private final int KEY_CTRL = 17;
        private final int KEY_DELETE = 46;
        private final int KEY_DOWN = 40;
        private final int KEY_END = 35;
        private final int KEY_ENTER = 13;
        private final int KEY_ESCAPE = 27;
        private final int KEY_HOME = 36;
        private final int KEY_LEFT = 37;
        private final int KEY_PAGEDOWN = 34;
        private final int KEY_PAGEUP = 33;
        private final int KEY_RIGHT = 39;
        private final int KEY_SHIFT = 16;
        private final int KEY_TAB = 9;
        private final int KEY_UP = 38;
        
        final ComboBox nChamp;
        final String resultTplRefPerso = "<div class=\"search-item-ref\">{label_fmt}</div>"; 
        Button ajouterChampsEtenduEtFermer;
        Button ajouterChampsEtendu;
        Button annulerAjouterChampEtendu;
        String idChamp = null;
        
        Panel conteneurGroupesChampsEtendus;
        final ComboBox groupesChampsEtendus;
        HTML indicationSaisieGroupe;
        
        private static ListeGroupesChampsEtendus cacheGroupes;
        
        private Timer timer = null;
        
        private static Map<String, String> cacheClesValeur;
        private HTML descriptionChamp = null;
        
        private Record rdSelectionne = null;
    private Record groupeSelectionne = null;
        private String valeurBrute = "";
        
        public FormulaireSaisieChampEtendu() {  
                super();
                setPaddings(3);
                setBodyBorder(false);
                
                indicationSaisieGroupe = new HTML("Vous pouvez ajouter plusieurs champs à la fois correspondant à un groupe "+
                                "par exemple les champs des projet 'sauvages de ma rue' ou 'florilèges', etc... <br />"+
                                "De nouveaux groupes seront ajoutés régulièrement en fonction des champs les plus utilisés");
                indicationSaisieGroupe.addStyleName("aideCreerChampEtendu");
                
                groupesChampsEtendus = new ComboBox();
                groupesChampsEtendus.setWidth("350px");
                groupesChampsEtendus.setLabel("Ajouter un groupe de champs");
                groupesChampsEtendus.setDisplayField("label") ;
                groupesChampsEtendus.setValueField("cle");
                groupesChampsEtendus.setEditable(false);
                groupesChampsEtendus.setHideTrigger(false);
                groupesChampsEtendus.setForceSelection(true);
                groupesChampsEtendus.setCls("champ-separation");
                groupesChampsEtendus.setValue("");
                
                conteneurGroupesChampsEtendus = new Panel();
                conteneurGroupesChampsEtendus.setBorder(false);
                conteneurGroupesChampsEtendus.setPaddings(0);
                conteneurGroupesChampsEtendus.setMargins(0);
                conteneurGroupesChampsEtendus.setLayout(new FormLayout());
                conteneurGroupesChampsEtendus.setWidth("100%");
                
                add(conteneurGroupesChampsEtendus);
                
                if(cacheGroupes == null) {
                        ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null);
                        lrceDao.obtenirGroupesChampsEtendus(this);
                } else {
                        this.rafraichir(cacheGroupes, false);
                }
                                
                HTML indicationSaisie = new HTML("Saisissez un nom de champ ou choisisez un nom proposé par l'autocomplétion "+
                                "Si vous choissisez un nom de champ existant vous pourrez profiter d'une autocomplétion "+
                                "sur les valeurs déjà saisies pour ce champ par les autres utilisateurs.<br /> "+
                                "Les champs de la forme 'label (clé)' sont des champs 'standards' ayant un rôle et une description " +
                                "bien définie");
                indicationSaisie.addStyleName("aideCreerChampEtendu");
                add(indicationSaisie);
                
                HorizontalPanel hp = new HorizontalPanel();
                hp.setBorderWidth(0);
                                
                nChamp = new ComboBox("Nom du champ", "nom_champ_etendu");
                nChamp.setWidth("350px");
                nChamp.setTpl(resultTplRefPerso);
                nChamp.setMode(ComboBox.REMOTE);
                nChamp.setItemSelector("div.search-item-ref");
                nChamp.setTypeAhead(false);  
                nChamp.setLoadingText("Recherche...");  
                nChamp.setHideTrigger(true);
                nChamp.setValidateOnBlur(false);
                Store store = initStoreChampsEtendusVide();
                store.load();
            nChamp.setStore(store);
                add(nChamp);
                
                descriptionChamp = new HTML();
                descriptionChamp.addStyleName("aideWikiChampEtendu");
                add(descriptionChamp);
                
                ajouterChampsEtenduEtFermer = new Button("Ajouter et fermer");
                ajouterChampsEtenduEtFermer.setTooltip("Ajouter un champ étendu ou un groupe de champs et fermer la fenêtre");
                ajouterChampsEtendu = new Button("Ajouter");
                ajouterChampsEtendu.setTooltip("Ajouter un champ étendu ou un groupe de champ");
                annulerAjouterChampEtendu = new Button("Annuler");
                annulerAjouterChampEtendu.setTooltip("Fermer la fenêtre sans ajouter de champ");
                
                hp.add(ajouterChampsEtenduEtFermer);
                hp.add(ajouterChampsEtendu);
                hp.add(annulerAjouterChampEtendu);      
                add(hp);
                
                ajouterListeners();
        }

        private void ajouterListeners() {
                ListenerConfig listenerConfigAutocompletion=new ListenerConfig();
            listenerConfigAutocompletion.setDelay(200);
            listenerConfigAutocompletion.setStopPropagation(false);
            listenerConfigAutocompletion.setStopEvent(true);
                
            nChamp.addKeyPressListener(new EventCallback() {

                        @Override
                        public void execute(EventObject e) {

                                switch(e.getKey()) {
                              
                                        case KEY_ALT:
                              case KEY_CTRL:
                              case KEY_END:
                              case KEY_HOME:
                              case KEY_LEFT:
                              case KEY_PAGEDOWN:
                              case KEY_PAGEUP:
                              case KEY_RIGHT:
                              case KEY_SHIFT:
                              case KEY_TAB:
                              case KEY_UP:
                        break;
                        
                          case KEY_ENTER:
                          if(rdSelectionne != null) {
                                nChamp.setValue(rdSelectionne.getAsString("label"));
                                valeurBrute = rdSelectionne.getAsString("cle");
                          }
                      break;
                        
                            case KEY_DOWN:
                          if(nChamp.getValueAsString().isEmpty() && !nChamp.isExpanded()) {
                                obtenirListeValeurs("*");
                          }
                        break;
                        
                            case KEY_ESCAPE:
                                surAnnulation();
                            break;
                            
                            default:
                                if(timer != null) {
                                        timer.cancel();
                                }
                                timer = new Timer() {
                                                        
                                                        @Override
                                                        public void run() {
                                                obtenirListeValeurs();
                                                        }
                                                };
                                                timer.schedule(300);
                                                valeurBrute = nChamp.getRawValue();
                                                nChamp.setRawValue(valeurBrute);
                                }
                        }
            },listenerConfigAutocompletion);
                
            nChamp.addListener(new ComboBoxListenerAdapter() {  
            @Override
                        public void onSelect(ComboBox comboBox, Record record, int index) { 
                rdSelectionne = record;
                telechargerEtAfficherDescriptionChamps(rdSelectionne.getAsString("cle"));
                nChamp.setRawValue(rdSelectionne.getAsString("label"));
                valeurBrute = rdSelectionne.getAsString("cle");
            }

                        @Override
                        public void onBlur(Field field) {
                if(rdSelectionne != null && !rdSelectionne.getAsString("cle").equals(valeurBrute)) {
                        nChamp.setRawValue(valeurBrute);                        
                } 
                telechargerEtAfficherDescriptionChamps(valeurBrute);
            }
         });
            
            groupesChampsEtendus.addListener(new ComboBoxListenerAdapter() {  
                        @Override
                        public void onSelect(ComboBox comboBox, Record record, int index) {  
                groupeSelectionne = record;
            }
             });
            
            ajouterChampsEtenduEtFermer.addListener(new ButtonListenerAdapter() {                       
                        @Override
                        public void onClick(Button button, EventObject e) {
                                if(doitAjouterGroupe()) {
                                        surValidationMultiple(renvoyerListeChampsEtendus(groupeSelectionne.getAsString("cle")));
                                } else {
                                        if(champEtenduEstValide()) {
                                                surValidation(validerEtRenvoyerChampEtendu());
                                        } else {
                                                Window.alert("Le nom du champ étendu ne peut pas être vide");
                                        }
                                }
                        }
                });
            
            ajouterChampsEtendu.addListener(new ButtonListenerAdapter() {                       
                        @Override
                        public void onClick(Button button, EventObject e) {
                                if(champEtenduEstValide()) {
                                        surAjout(validerEtRenvoyerChampEtendu());
                                        raz();
                                } else {
                                        Window.alert("Le nom du champ étendu ne peut pas être vide");
                                }
                        }
                });
            
            annulerAjouterChampEtendu.addListener(new ButtonListenerAdapter() {                 
                        @Override
                        public void onClick(Button button, EventObject e) {
                                surAnnulation();
                        }
                });
        }
        
        private void raz() {
                timer = null;
                idChamp = null;
                nChamp.clearValue();
                nChamp.focus();
        }
        
        private ChampSaisieEtendu validerEtRenvoyerChampEtendu() {
                String valeurChamp = nChamp.getRawValue();
                // Valeur contient soit la clé, soit le label s'il existe
                // valeur brute contient toujours la clé
                // TODO: utiliser les champs de google et pas ceux de GWT-EXT qui puent du cul
                ChampSaisieEtendu retour = new ChampSaisieEtendu(valeurChamp, valeurBrute);
                retour.setId(valeurBrute);
                return retour;
        }
        
        private List<ChampSaisieEtendu> renvoyerListeChampsEtendus(String groupe) {     
                List<ChampSaisieEtendu> champsDuGroupe = new ArrayList<ChampSaisieEtendu>();
                HashMap<String, String> listeChampsEtendus = cacheGroupes.get(groupe);
                for (Iterator<String> iterator = listeChampsEtendus.keySet().iterator(); iterator.hasNext();) {
                        String cle = iterator.next();
                        String label = listeChampsEtendus.get(cle);
                        ChampSaisieEtendu champ = new ChampSaisieEtendu(label, cle);
                        champsDuGroupe.add(champ);
                }

                return champsDuGroupe;
        }
        
        private boolean doitAjouterGroupe() {
                return groupeSelectionne != null && !groupeSelectionne.getAsString("cle").equals("");
        }
        
        private boolean champEtenduEstValide() {
                String valeurChamp = nChamp.getRawValue();
                return (valeurChamp != null && !valeurChamp.isEmpty());
        }
        
        private boolean estUnChampSelectionne(String valeur) {
                return cacheClesValeur.containsValue(valeur);
        }
        
        private void obtenirListeValeurs() {
                obtenirListeValeurs(nChamp.getRawValue());
        }
        
        private void obtenirListeValeurs(String valeur) {
                ListeReferentielChampsEtendusDAO lrce = new ListeReferentielChampsEtendusDAO(null);
                lrce.obtenirListeNomsChampsEtendus(this, valeur+"*");
        }
        
        public abstract void surAjout(ChampSaisieEtendu champ);
        public abstract void surAjoutMultiple(List<ChampSaisieEtendu> champs);
        public abstract void surValidation(ChampSaisieEtendu champ);
        public abstract void surValidationMultiple(List<ChampSaisieEtendu> champs);
        public abstract void surAnnulation();
        
        public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {     
                
                if(nouvelleDonnees instanceof ListeChampsEtendus) {
                        int i = 0;
                                        
                        ListeChampsEtendus clesLabels = (ListeChampsEtendus)nouvelleDonnees;    
                        cacheClesValeur = clesLabels;
                        Object[][] refData = new Object[clesLabels.keySet().size()][3];
                        
                        for (Iterator<String> it = clesLabels.keySet().iterator(); it.hasNext();) 
                        {
                                String cle = it.next();
                                String label = clesLabels.get(cle);
                                
                                refData[i][0]= cle;
                                refData[i][1]= label;
                                if(cle.equals(label.toLowerCase())) {
                                        refData[i][2]= label;
                                } else {
                                        refData[i][2]= label+" ("+cle+")";
                                }

                                i++;
                        }
                        
                        FieldDef defCle = new StringFieldDef("cle");
                        FieldDef defLabel = new StringFieldDef("label");
                        FieldDef defLabelFmt = new StringFieldDef("label_fmt");
                        FieldDef[] defTab = {defCle, defLabel, defLabelFmt};
                        
                        RecordDef rd = new RecordDef(defTab);
                        
                        final MemoryProxy dataProxy = new MemoryProxy(refData);
                        final ArrayReader reader = new ArrayReader(rd);         
                                                        
                        Store store=new Store(dataProxy,reader);
                        
                        nChamp.setStore(store);
                        store.load();
                }
                
                if(nouvelleDonnees instanceof ListeGroupesChampsEtendus) {
                        cacheGroupes  = (ListeGroupesChampsEtendus)nouvelleDonnees;
                        groupesChampsEtendus.setStore(getGroupesChampsEtendusStore(cacheGroupes));
                        if(cacheGroupes.size() > 0) {
                                conteneurGroupesChampsEtendus.add(indicationSaisieGroupe);
                                conteneurGroupesChampsEtendus.add(groupesChampsEtendus);
                                doLayout();
                        }
                }
        }
        
    
    private void telechargerEtAfficherDescriptionChamps(final String cle) {
                ListeReferentielChampsEtendusDAO.telechargerDescriptionWikini(cle, new Callback<String, String>() {                     
                        @Override
                        public void onSuccess(String description) {
                                afficherDescriptionEtLienWikiChampEtendu(cle, description);
                        }
                        
                        @Override
                        public void onFailure(String reason) {
                                // rien
                        }
                });
        }
    
    private void afficherDescriptionEtLienWikiChampEtendu(final String cle, String description) {
        if(description.trim().isEmpty()) {
                        String urlDesc = ListeReferentielChampsEtendusDAO.obtenirUrlEditionDescriptionWiki(cle);
                        descriptionChamp.setHTML("<span> Aucune description n'existe pour ce champ.<br />" +
                                        "Vous pouvez la remplir sur cette page :" +
                                        "<a id=\"lien_description_wiki_ce_"+cle+"\" href="+urlDesc+" target=\"_blank\">"+cle+"</span></span>");
                        Ext.get("lien_description_wiki_ce_"+cle).addListener("click", new EventCallback() {     
                                @Override
                                public void execute(EventObject e) {
                                        ListeReferentielChampsEtendusDAO.creerPageWikini(cle);
                                }
                        });
                } else {
                        descriptionChamp.setHTML("<span class=\"descriptionChampEtenduTitre\">Description :</span> "+description);
                }
    }
        
        private Store getGroupesChampsEtendusStore(ListeGroupesChampsEtendus listeGroupesChampsEtendus) {
                int i = 1;              
                Object[][] valeurs = new Object[listeGroupesChampsEtendus.size()+1][2];
                
                valeurs[0][0] = "...";
                valeurs[0][1] = "";
                if(listeGroupesChampsEtendus.size() > 0) {
                        for (Iterator<String> it = listeGroupesChampsEtendus.keySet().iterator(); it.hasNext();) 
                        {
                                String cle = it.next();
                                valeurs[i][0]= cle;
                                valeurs[i][1]= cle;
                                i++;
                        }
                }                                       
                SimpleStore store = new SimpleStore(new String[] {"label","cle"},valeurs);
                store.load();
                return store;
        }
        
        private Store initStoreChampsEtendusVide() {
                Object[][] refData = new Object[0][1];
                
                FieldDef defLabel = new StringFieldDef("label");
                FieldDef defCle = new StringFieldDef("cle");
                FieldDef[] defTab = {defLabel, defCle};
                
                RecordDef rd = new RecordDef(defTab);
                
                final MemoryProxy dataProxy = new MemoryProxy(refData);
                final ArrayReader reader = new ArrayReader(rd);         
                                                
                Store store = new Store(dataProxy,reader);
                
                return store;
        }
}