Subversion Repositories eFlore/Applications.coel

Rev

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

package org.tela_botanica.client.modeles;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;

import org.tela_botanica.client.util.UtilArray;

import com.extjs.gxt.ui.client.data.BaseModelData;

/**
 * @author jpm
 *
 */
public abstract class aDonnee extends BaseModelData implements Serializable {

        /**
         * Identifiant pour sérialisé l'objet...
         */
        private static final long serialVersionUID = 3527760464061629791L;

        /**
         * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par
         * cette fonction qui retire les charactères nuls qui font planter
         * l'affichage, il ne faut pas utiliser get directement
         * 
         * @param cle
         * @return la valeur associée à la clé
         */
        protected String renvoyerValeurCorrecte(String cle) {
                String sortie = "";
                if (this.get(cle) != null) {
                        String valeur = this.get(cle);
                        if (! valeur.equals("null")) {
                                char nullChar = '\u0000';
                                String sNull = "" + nullChar;
                                valeur = valeur.replaceAll(sNull, "");
                                sortie =  valeur;
                        }
                }
                return sortie;
        }
        
        /**
         * Ajoute un nouvel élément avec son type à une chaine dénormalisée.
         * Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".
         * Si l'élément existe déjà, il ne sera pas ajouté.
         * 
         * @param champ le nom du champ dénormalisé
         * @param type le type de la valeur à ajouter
         * @param valeur la valeur à ajouter
         */
        protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {
                if (valeur instanceof String) {
                        String chaineExistante = renvoyerValeurCorrecte(champ);
                        if (chaineExistante.equals("")) {
                                this.set(champ, type+"##"+valeur);
                        } else {
                                // Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
                                if (!chaineExistante.matches("(^|;;)"+type+"##"+valeur+"(;;|$)")) {
                                        this.set(champ, chaineExistante+";;"+type+"##"+valeur);
                                }
                        }
                }
        }
        
        /**
         * Ajoute un nouvel élément sans type à une chaine dénormalisée.
         * Champ de type "truk" contenant seulement des valeurs séparées par ";;".
         * Si l'élément existe déjà, il ne sera pas ajouté.
         * 
         * @param champ le nom du champ dénormalisé
         * @param valeur la valeur à ajouter
         */
        protected void ajouterChaineDenormalise(String champ, Object valeur) {
                if (valeur instanceof String) {
                        String chaineExistante = renvoyerValeurCorrecte(champ);
                        if (chaineExistante.equals("")) {
                                this.set(champ, valeur);
                        } else {
                                // Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
                                if (!chaineExistante.matches("(^|;;)"+valeur+"(;;|$)")) {
                                        this.set(champ, chaineExistante+";;"+valeur);
                                }
                        }
                }
        }
        
        /**
         * Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").
         * 
         * @param champ le nom du champ dénormalisé
         * @param type le type de la valeur à ajouter
         * @param valeur la valeur à ajouter
         */
        protected void setChaineDenormaliseUnique(String champ, String type, Object valeur) {
                if (valeur instanceof String) {
                        this.set(champ, type+"##"+valeur);
                }
        }
        
        /**
         * Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").
         * 
         * @param champ le nom du champ dénormalisé
         */
        protected String getChaineDenormaliseUnique(String champ) {
                String sortie = renvoyerValeurCorrecte(champ);
                
                if (!sortie.equals("")) {
                        sortie = sortie.replaceFirst("^AUTRE##", "");
                }
                
                return sortie;
        }
        
        protected String getInfoDenormaliseParType(String chaineExistante, String type) {
                String sortie = "";
                if (!chaineExistante.equals("")) {
                        String[] valeurs = chaineExistante.split(";;");
                        for (int i = 0; i < valeurs.length; i++) {
                                if (valeurs[i].startsWith(type+"##")) {
                                        sortie =  valeurs[i].replaceFirst("^"+type+"##", "");
                                }
                        }
                }
                return sortie;
        }
        
        
        /**
         * Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur
         * 
         * @param champ le nom du champ dénormalisé
         * @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)
         */
        
        public Object getChaineDenormaliseAsMapOrList(String champ)     {
                                
                        Object retourObjet = null;
                        
                        String valeurChamp = renvoyerValeurCorrecte(champ);
                        
                        if ((valeurChamp!=null)&&(!valeurChamp.trim().equals("")))      {
                                String[] valeurs = valeurChamp.split(";;");
                        
                                if (valeurs.length > 0) {
                                        if (valeurs[0].contains("##"))  {
                                                // Les champs sont typés, on en fait une Map
                                                HashMap mapValeurs = new HashMap();
                                                
                                                for (int i = 0; i < valeurs.length; i++)        {
                                                        String typeEtValeur[] = valeurs[i].split("##");
                                                        mapValeurs.put(typeEtValeur[0], typeEtValeur[1]);                                               
                                                }
                                                
                                                retourObjet = mapValeurs;
                                        }
                                        else    {
                                                
                                                //Les champs ne sont pas typés, on en fait une Liste
                                                LinkedList listeValeurs = new LinkedList<String>();
                                                for (int i = 0; i < valeurs.length; i++)        {
                                                        if ((valeurs[i]!=null)&&(!valeurs[i].equals("")))       {
                                                                listeValeurs.add(valeurs[i]);
                                                        }
                                                }
                                                retourObjet = listeValeurs;
                                        }
                                        
                                }
                        }
                        
                        return retourObjet;
                        
        }
        
        
        /**
         * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
         * Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.
         * 
         * @param champ le nom du champ dénormalisé
         * @param type le type de la valeur à modifier
         * @param valeur la valeur pour le type en question
         */
        protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {
                if (valeur instanceof String) {
                        String chaineExistante = renvoyerValeurCorrecte(champ);
                        if (chaineExistante.equals("")) {
                                this.set(champ, type+"##"+valeur);
                        } else {
                                String[] valeurs = chaineExistante.split(";;");
                                for (int i = 0; i < valeurs.length; i++) {
                                        if (valeurs[i].startsWith(type+"##") || i == (valeurs.length -1)) {
                                                valeurs[i] = type+"##"+valeur;
                                                break;
                                        }
                                }
                                this.set(champ, UtilArray.implode(valeurs, ";;"));
                        }
                }
        }
        
        protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {
                String sortie = "";
                if (!chaineExistante.equals("")) {
                        String[] valeurs = chaineExistante.split(";;");
                        if (valeurs.length >= position) {
                                for (int i = 0; i < valeurs.length; i++) {
                                        if (i == (position - 1)) {
                                                if (valeurs[i].contains("##")) {
                                                        sortie =  valeurs[i].replaceFirst("^[^#]+##", "");
                                                } else {
                                                        sortie =  valeurs[i];
                                                }
                                                break;
                                        }
                                }
                        }
                }
                return sortie;
        }
        
        /**
         * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
         * Remplace par la valeur l'instance dont la position a été indiquée.
         * Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.
         * Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.
         * 
         * @param champ le nom du champ dénormalisé
         * @param position le type de la valeur à modifier
         * @param valeur la valeur à remplacer à la position indiquée
         */
        protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {
                if (valeur instanceof String) {
                        String chaineExistante = renvoyerValeurCorrecte(champ);
                        if (!chaineExistante.equals("")) {
                                String[] valeurs = chaineExistante.split(";;");
                                if (valeurs.length == 0) {
                                        this.set(champ, valeur);
                                } else if (valeurs.length >= position) {
                                        for (int i = 0; i < valeurs.length; i++) {
                                                if (i == (position - 1)) {
                                                        valeurs[i] = (String) valeur;
                                                        break;
                                                }
                                        }
                                        this.set(champ, UtilArray.implode(valeurs, ";;"));
                                }
                        }
                }
        }
        
        public String getDateModification() {
                return (String) renvoyerValeurCorrecte("cmhl_date_modification");
        }
        
        public String getNotes() {
                return (String) renvoyerValeurCorrecte("cmhl_notes");
        }
        
        public String getIdModifierPar() {
                return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");
        }
        
        public String getIdEtat() {
                return (String) renvoyerValeurCorrecte("cmhl_ce_etat");
        }
        
        public String getIp() {
                return (String) renvoyerValeurCorrecte("cmhl_ip");
        }
        
        /** (non-Javadoc)
         * @see java.lang.Object#toString()
         */
        public String toString() {
                String sortie = "";
                
                // Champs du BaseModelData
                Set<String> proprietes = this.getProperties().keySet();
                for (Iterator<String> it = proprietes.iterator(); it.hasNext();) {
                        String cle = it.next();
                        if (!this.get(cle).equals("")) {
                                sortie += cle+" : "+this.get(cle)+"\n";
                        }
                }
                
                return sortie;
        }
}