ips1ap101.lib.core.db.xdp.RecursoCachedRowSetDataProvider.java Source code

Introduction

Here is the source code for ips1ap101.lib.core.db.xdp.RecursoCachedRowSetDataProvider.java

Source

/*
 * Este programa es software libre; usted puede redistribuirlo y/o modificarlo bajo los trminos
 * de la licencia "GNU General Public License" publicada por la Fundacin "Free Software Foundation".
 * Este programa se distribuye con la esperanza de que pueda ser til, pero SIN NINGUNA GARANTIA;
 * vea la licencia "GNU General Public License" para obtener cursor informacion.
 */
package ips1ap101.lib.core.db.xdp;

import com.sun.data.provider.DataProviderException;
import com.sun.data.provider.FieldKey;
import com.sun.data.provider.RowKey;
import com.sun.data.provider.TableCursorVetoException;
import com.sun.data.provider.TableDataAdapter;
import com.sun.data.provider.TableDataProvider;
import com.sun.data.provider.impl.CachedRowSetDataProvider;
import com.sun.data.provider.impl.TableRowDataProvider;
import com.sun.sql.rowset.CachedRowSetX;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.sql.rowset.CachedRowSet;
import javax.sql.rowset.spi.SyncResolver;
import ips1ap101.lib.base.BaseBundle;
import ips1ap101.lib.base.bundle.BundleWebui;
import ips1ap101.lib.base.constant.CBM;
import ips1ap101.lib.base.entity.enumeration.CondicionEjeFunEnumeration;
import ips1ap101.lib.base.entity.enumeration.OperadorComEnumeration;
import ips1ap101.lib.base.entity.enumeration.TipoRastroFunEnumeration;
import ips1ap101.lib.base.util.BitUtils;
import ips1ap101.lib.base.util.LongUtils;
import ips1ap101.lib.base.util.NumUtils;
import ips1ap101.lib.base.util.TimeUtils;
import ips1ap101.lib.core.app.Bitacora;
import ips1ap101.lib.core.app.CampoBusqueda;
import ips1ap101.lib.core.app.ConsultaBusqueda;
import ips1ap101.lib.core.app.ExcepcionAplicacion;
import ips1ap101.lib.core.app.FiltroBusqueda;
import ips1ap101.lib.core.app.OrdenConjuntoResultados;
import ips1ap101.lib.core.app.TLC;
import ips1ap101.lib.core.constant.EAC;
import ips1ap101.lib.core.constant.Global;
import ips1ap101.lib.core.control.RastroFuncion;
import ips1ap101.lib.core.control.SeudoTareaUsuario;
import ips1ap101.lib.core.db.util.DB;
import ips1ap101.lib.core.db.util.DBUtils;
import ips1ap101.lib.core.db.util.InterpreteSql;
import ips1ap101.lib.core.enumeration.EnumColumnaEtiqueta;
import ips1ap101.lib.core.enumeration.EnumOpcionZumNodo;
import ips1ap101.lib.core.jsf.JSF;
import ips1ap101.lib.core.util.EA;
import ips1ap101.lib.core.web.app.RowChecker;
import org.apache.commons.lang.StringUtils;

/**
 * @author Jorge Campins
 */
public class RecursoCachedRowSetDataProvider extends CachedRowSetDataProvider {

    /**
     * Conserva el valor de la propiedad testing.
     */
    private boolean testing = EA.isTestingStage();

    /**
     * Conserva el valor de la propiedad filasElegidas.
     */
    private Set filasElegidas = new LinkedHashSet();

    /**
     * Conserva el valor de la propiedad listaRastroFuncion.
     */
    private Map<String, RastroFuncion> listaRastroFuncion;

    /**
     * Conserva el valor de la propiedad listaTareasUsuario.
     */
    protected List<SeudoTareaUsuario> listaTareasUsuario;

    /**
     * Creates a new instance of RecursoCachedRowSetDataProvider
     */
    public RecursoCachedRowSetDataProvider() {
        super();
        init();
    }

    /**
     * Creates a new instance of RecursoCachedRowSetDataProvider
     */
    public RecursoCachedRowSetDataProvider(CachedRowSet cachedRowSet) {
        super(cachedRowSet);
        init();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void setCachedRowSet(CachedRowSet cachedRowSet) {
        super.setCachedRowSet(cachedRowSet);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isRowAvailable(RowKey row) throws DataProviderException {
        return row != null && super.isRowAvailable(row);
    }

    public boolean isNotRowAvailable(RowKey row) throws DataProviderException {
        return !isRowAvailable(row);
    }

    /**
     * Conserva el valor de la propiedad rowChecker.
     */
    private RowChecker rowChecker;

    /**
     * @return the rowChecker
     */
    public RowChecker getRowChecker() {
        return rowChecker;
    }

    /**
     * @param rowChecker the rowChecker to set
     */
    public void setRowChecker(RowChecker rowChecker) {
        this.rowChecker = rowChecker;
    }

    /**
     * Conserva el valor de la propiedad tipoRastroFuncion.
     */
    private TipoRastroFunEnumeration tipoRastroFuncion = TipoRastroFunEnumeration.EXITO;

    /**
     * @return the tipoRastroFuncion
     */
    public TipoRastroFunEnumeration getTipoRastroFuncion() {
        return tipoRastroFuncion;
    }

    /**
     * @param tipoRastroFuncion the tipoRastroFuncion to set
     */
    public void setTipoRastroFuncion(TipoRastroFunEnumeration tipoRastroFuncion) {
        this.tipoRastroFuncion = tipoRastroFuncion;
    }

    private void init() {
        super.addTableDataListener(new TableDataAdapter() {

            @Override
            public void valueChanged(TableDataProvider tdp, FieldKey fk, RowKey rk, Object o3, Object o4) {
                recursoCachedRowSetDataProvider_valueChanged(tdp, fk, rk, o3, o4);
            }

        });
    }

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a interfaces">
    public boolean isRecursoIdentificable() {
        return this instanceof RecursoIdentificableDataProvider && StringUtils
                .isNotBlank(((RecursoIdentificableDataProvider) this).getColumnaIdentificacionRecurso());
    }

    public boolean isRecursoVersionable() {
        return this instanceof RecursoVersionableDataProvider
                && StringUtils.isNotBlank(((RecursoVersionableDataProvider) this).getColumnaVersionRecurso());
    }

    public boolean isRecursoCodificable() {
        return this instanceof RecursoCodificableDataProvider
                && StringUtils.isNotBlank(((RecursoCodificableDataProvider) this).getColumnaCodigoRecurso());
    }

    public boolean isRecursoNombrable() {
        return this instanceof RecursoNombrableDataProvider
                && StringUtils.isNotBlank(((RecursoNombrableDataProvider) this).getColumnaNombreRecurso());
    }

    public boolean isRecursoDescriptible() {
        return this instanceof RecursoDescriptibleDataProvider
                && StringUtils.isNotBlank(((RecursoDescriptibleDataProvider) this).getColumnaDescripcionRecurso());
    }

    public boolean isRecursoPersonalizable() {
        return this instanceof RecursoPersonalizableDataProvider && StringUtils
                .isNotBlank(((RecursoPersonalizableDataProvider) this).getColumnaPropietarioRecurso());
    }

    public boolean isRecursoSegmentable() {
        return this instanceof RecursoSegmentableDataProvider
                && StringUtils.isNotBlank(((RecursoSegmentableDataProvider) this).getColumnaSegmentoRecurso());
    }

    public boolean isRecursoJerarquizable() {
        return this instanceof RecursoJerarquizableDataProvider
                && StringUtils.isNotBlank(((RecursoJerarquizableDataProvider) this).getColumnaRecursoSuperior());
    }

    public boolean isRecursoDesactivable() {
        return this instanceof RecursoDesactivableDataProvider
                && StringUtils.isNotBlank(((RecursoDesactivableDataProvider) this).getColumnaEsRecursoInactivo());
    }

    public boolean isRecursoEnumerable() {
        return this instanceof RecursoEnumerableDataProvider
                && StringUtils.isNotBlank(((RecursoEnumerableDataProvider) this).getColumnaNumeroRecurso());
    }

    public boolean isRecursoLocalizable() {
        return this instanceof RecursoLocalizableDataProvider;
    }

    public boolean isRecursoConsultable() {
        return this instanceof RecursoConsultableDataProvider;
    }

    public RecursoIdentificableDataProvider getRecursoIdentificableDataProvider() {
        return isRecursoIdentificable() ? (RecursoIdentificableDataProvider) this : null;
    }

    public RecursoVersionableDataProvider getRecursoVersionableDataProvider() {
        return isRecursoVersionable() ? (RecursoVersionableDataProvider) this : null;
    }

    public RecursoCodificableDataProvider getRecursoCodificableDataProvider() {
        return isRecursoCodificable() ? (RecursoCodificableDataProvider) this : null;
    }

    public RecursoNombrableDataProvider getRecursoNombrableDataProvider() {
        return isRecursoNombrable() ? (RecursoNombrableDataProvider) this : null;
    }

    public RecursoDescriptibleDataProvider getRecursoDescriptibleDataProvider() {
        return isRecursoDescriptible() ? (RecursoDescriptibleDataProvider) this : null;
    }

    public RecursoPersonalizableDataProvider getRecursoPersonalizableDataProvider() {
        return isRecursoPersonalizable() ? (RecursoPersonalizableDataProvider) this : null;
    }

    public RecursoSegmentableDataProvider getRecursoSegmentableDataProvider() {
        return isRecursoSegmentable() ? (RecursoSegmentableDataProvider) this : null;
    }

    public RecursoJerarquizableDataProvider getRecursoJerarquizableDataProvider() {
        return isRecursoJerarquizable() ? (RecursoJerarquizableDataProvider) this : null;
    }

    public RecursoDesactivableDataProvider getRecursoDesactivableDataProvider() {
        return isRecursoDesactivable() ? (RecursoDesactivableDataProvider) this : null;
    }

    public RecursoEnumerableDataProvider getRecursoEnumerableDataProvider() {
        return isRecursoEnumerable() ? (RecursoEnumerableDataProvider) this : null;
    }

    public RecursoLocalizableDataProvider getRecursoLocalizableDataProvider() {
        return isRecursoLocalizable() ? (RecursoLocalizableDataProvider) this : null;
    }

    public RecursoConsultableDataProvider getRecursoConsultableDataProvider() {
        return isRecursoConsultable() ? (RecursoConsultableDataProvider) this : null;
    }

    public Long getIdentificacionRecurso() {
        return isRecursoIdentificable() ? getRecursoIdentificableDataProvider().getIdentificacionRecurso() : null;
    }

    public Long getIdentificacionRecurso(RowKey rowKey) {
        return isRecursoIdentificable() ? getRecursoIdentificableDataProvider().getIdentificacionRecurso(rowKey)
                : null;
    }

    public Long getVersionRecurso() {
        return isRecursoVersionable() ? getRecursoVersionableDataProvider().getVersionRecurso() : null;
    }

    public Long getVersionRecurso(RowKey rowKey) {
        return isRecursoVersionable() ? getRecursoVersionableDataProvider().getVersionRecurso(rowKey) : null;
    }

    public String getCodigoRecurso() {
        return isRecursoCodificable() ? getRecursoCodificableDataProvider().getCodigoRecurso() : null;
    }

    public String getCodigoRecurso(RowKey rowKey) {
        return isRecursoCodificable() ? getRecursoCodificableDataProvider().getCodigoRecurso(rowKey) : null;
    }

    public String getNombreRecurso() {
        return isRecursoNombrable() ? getRecursoNombrableDataProvider().getNombreRecurso() : null;
    }

    public String getNombreRecurso(RowKey rowKey) {
        return isRecursoNombrable() ? getRecursoNombrableDataProvider().getNombreRecurso(rowKey) : null;
    }

    public Long getPropietarioRecurso() {
        return isRecursoPersonalizable() ? getRecursoPersonalizableDataProvider().getPropietarioRecurso() : null;
    }

    public Long getPropietarioRecurso(RowKey rowKey) {
        return isRecursoPersonalizable() ? getRecursoPersonalizableDataProvider().getPropietarioRecurso(rowKey)
                : null;
    }

    public Long getSegmentoRecurso() {
        return isRecursoSegmentable() ? getRecursoSegmentableDataProvider().getSegmentoRecurso() : null;
    }

    public Long getSegmentoRecurso(RowKey rowKey) {
        return isRecursoSegmentable() ? getRecursoSegmentableDataProvider().getSegmentoRecurso(rowKey) : null;
    }

    public Long getRecursoSuperior() {
        return isRecursoJerarquizable() ? getRecursoJerarquizableDataProvider().getRecursoSuperior() : null;
    }

    public Long getRecursoSuperior(RowKey rowKey) {
        return isRecursoJerarquizable() ? getRecursoJerarquizableDataProvider().getRecursoSuperior(rowKey) : null;
    }

    public Boolean getEsRecursoInactivo() {
        return isRecursoDesactivable() ? getRecursoDesactivableDataProvider().getEsRecursoInactivo() : null;
    }

    public Boolean getEsRecursoInactivo(RowKey rowKey) {
        return isRecursoDesactivable() ? getRecursoDesactivableDataProvider().getEsRecursoInactivo(rowKey) : null;
    }

    public Integer getNumeroRecurso() {
        return isRecursoEnumerable() ? getRecursoEnumerableDataProvider().getNumeroRecurso() : null;
    }

    public Integer getNumeroRecurso(RowKey rowKey) {
        return isRecursoEnumerable() ? getRecursoEnumerableDataProvider().getNumeroRecurso(rowKey) : null;
    }

    public String getUrl() {
        return isRecursoLocalizable() ? getRecursoLocalizableDataProvider().getUrl() : null;
    }

    public String getUrl(RowKey rowKey) {
        return isRecursoLocalizable() ? getRecursoLocalizableDataProvider().getUrl(rowKey) : null;
    }

    public long getFuncionConsultarRecurso() {
        return isRecursoConsultable() ? getRecursoConsultableDataProvider().getFuncionConsultarRecurso() : null;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Getters y Setters de propiedades propias">
    /**
     * Getter para propiedad filasElegidas.
     *
     * @return Valor de la propiedad filasElegidas.
     */
    public Set getFilasElegidas() {
        return filasElegidas;
    }

    public boolean esFilaElegida(TableRowDataProvider tableRowDataProvider) {
        return tableRowDataProvider != null && esFilaElegida(tableRowDataProvider.getTableRow());
    }

    public boolean esFilaElegida(RowKey rowKey) {
        return rowKey != null && getFilasElegidas().contains(rowKey);
    }

    public void eligeFila(TableRowDataProvider tableRowDataProvider, boolean eleccion) {
        if (tableRowDataProvider != null) {
            eligeFila(tableRowDataProvider.getTableRow(), eleccion);
        }
    }

    public void eligeFila(RowKey rowKey, boolean eleccion) {
        if (eleccion) {
            getFilasElegidas().add(rowKey);
        } else {
            getFilasElegidas().remove(rowKey);
        }
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Getters y Setters de propiedades de RecursoCachedRowSet">
    /**
     * Getter para propiedad recursoCachedRowSetXImpl.
     *
     * @return Valor de la propiedad recursoCachedRowSetXImpl.
     */
    public RecursoCachedRowSet getRecursoCachedRowSet() {
        CachedRowSet crs = getCachedRowSet();
        return crs instanceof RecursoCachedRowSet ? (RecursoCachedRowSet) crs : null;
    }

    /**
     * @return the nombreClaseRecurso
     */
    public String getNombreClaseRecurso() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getNombreClaseRecurso();
    }

    /**
     * @param nombreClaseRecurso the nombreClaseRecurso to set
     */
    public void setNombreClaseRecurso(String nombreClaseRecurso) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setNombreClaseRecurso(nombreClaseRecurso);
        }
    }

    /**
     * Getter para propiedad inicializado.
     *
     * @return Valor de la propiedad inicializado.
     */
    public boolean isInicializado() {
        return getRecursoCachedRowSet() == null ? false : getRecursoCachedRowSet().isInicializado();
    }

    /**
     * Setter para propiedad inicializado.
     *
     * @param inicializado Nuevo valor de la propiedad inicializado.
     */
    protected void setInicializado(boolean inicializado) {
        if (getRecursoCachedRowSet() != null) {
            getRecursoCachedRowSet().setInicializado(inicializado);
        }
    }

    /**
     * Getter para propiedad soloReferencia.
     *
     * @return Valor de la propiedad soloReferencia.
     */
    public boolean isSoloReferencia() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isSoloReferencia();
    }

    /**
     * Setter para propiedad soloReferencia.
     *
     * @param soloReferencia Nuevo valor de la propiedad soloReferencia.
     */
    public void setSoloReferencia(boolean soloReferencia) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setSoloReferencia(soloReferencia);
        }
    }

    /**
     * Getter para propiedad filaEscogida.
     *
     * @return Valor de la propiedad filaEscogida.
     */
    public RowKey getFilaEscogida() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getFilaEscogida();
    }

    /**
     * Setter para propiedad filaEscogida.
     *
     * @param filaElegida Nuevo valor de la propiedad filaEscogida.
     */
    public void setFilaEscogida() {
        // Bitacora.trace(getClass(), "setFilaEscogida");
        if (isInicializado()) {
            try {
                if (isCursorRowAvailable()) {
                    setFilaEscogida(getCursorRow());
                } else {
                    resetFilaEscogida();
                }
            } catch (Exception ex) {
                resetFilaEscogida();
            }
        }
    }

    /**
     * Setter para propiedad filaEscogida.
     *
     * @param filaElegida Nuevo valor de la propiedad filaEscogida.
     */
    public void setFilaEscogida(RowKey rowKey) {
        Bitacora.trace(getClass(), "setFilaEscogida", "RowKey=" + rowKey);
        if (isRowAvailable(rowKey) && isInicializado()) {
            getRecursoCachedRowSet().setFilaEscogida(rowKey);
            Long identificacion = null;
            if (isRecursoIdentificable()) {
                identificacion = getRecursoIdentificableDataProvider().getIdentificacionRecurso(rowKey);
            }
            setIdentificacionFilaEscogida(identificacion);
            Integer numero = null;
            if (isRecursoEnumerable()) {
                numero = getRecursoEnumerableDataProvider().getNumeroRecurso(rowKey);
            }
            setNumeroFilaEscogida(numero);
            String codigo = null;
            if (isRecursoCodificable()) {
                codigo = getRecursoCodificableDataProvider().getCodigoRecurso(rowKey);
            }
            setCodigoFilaEscogida(codigo);
            Bitacora.trace(getClass(), "setFilaEscogida", "RowKey=" + rowKey, "identificacion=" + identificacion,
                    "numero=" + numero, "codigo=" + codigo);
        } else {
            resetFilaEscogida();
        }
    }

    /**
     * Setter para propiedad filaEscogida.
     *
     * @param filaElegida Nuevo valor de la propiedad filaEscogida.
     */
    protected void resetFilaEscogida() {
        // Bitacora.trace(getClass(), "resetFilaEscogida");
        if (isInicializado()) {
            getRecursoCachedRowSet().setFilaEscogida(null);
            getRecursoCachedRowSet().setIdentificacionFilaEscogida(null);
            getRecursoCachedRowSet().setCodigoFilaEscogida(null);
        }
    }

    public boolean esFilaEscogida(RowKey rowKey) {
        RowKey filaEscogida = !isInicializado() ? null : getRecursoCachedRowSet().getFilaEscogida();
        return filaEscogida != null && rowKey != null && rowKey.equals(filaEscogida);
    }

    /**
     * Getter para propiedad identificacionFilaEscogida.
     *
     * @return Valor de la propiedad identificacionFilaEscogida.
     */
    public Long getIdentificacionFilaEscogida() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getIdentificacionFilaEscogida();
    }

    /**
     * Setter para propiedad identificacionFilaEscogida.
     *
     * @param identificacionFilaEscogida Nuevo valor de la propiedad identificacionFilaEscogida.
     */
    protected void setIdentificacionFilaEscogida(Long identificacionFilaEscogida) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setIdentificacionFilaEscogida(identificacionFilaEscogida);
        }
    }

    /**
     * Getter para propiedad numeroFilaEscogida.
     *
     * @return Valor de la propiedad numeroFilaEscogida.
     */
    public Integer getNumeroFilaEscogida() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getNumeroFilaEscogida();
    }

    /**
     * Setter para propiedad numeroFilaEscogida.
     *
     * @param numeroFilaEscogida Nuevo valor de la propiedad numeroFilaEscogida.
     */
    protected void setNumeroFilaEscogida(Integer numeroFilaEscogida) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setNumeroFilaEscogida(numeroFilaEscogida);
        }
    }

    /**
     * Getter para propiedad codigoFilaEscogida.
     *
     * @return Valor de la propiedad codigoFilaEscogida.
     */
    public String getCodigoFilaEscogida() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getCodigoFilaEscogida();
    }

    /**
     * Setter para propiedad codigoFilaEscogida.
     *
     * @param codigoFilaEscogida Nuevo valor de la propiedad codigoFilaEscogida.
     */
    protected void setCodigoFilaEscogida(String codigoFilaEscogida) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setCodigoFilaEscogida(codigoFilaEscogida);
        }
    }

    /**
     * Getter para propiedad tablaMaestro.
     *
     * @return Valor de la propiedad tablaMaestro.
     */
    public String getTablaMaestro() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getTablaMaestro();
    }

    /**
     * Setter para propiedad tablaMaestro.
     *
     * @param tablaMaestro Nuevo valor de la propiedad tablaMaestro.
     */
    public void setTablaMaestro(String tablaMaestro) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setTablaMaestro(tablaMaestro);
        }
    }

    /**
     * Getter para propiedad columnaMaestro.
     *
     * @return Valor de la propiedad columnaMaestro.
     */
    public String getColumnaMaestro() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getColumnaMaestro();
    }

    /**
     * Setter para propiedad columnaMaestro.
     *
     * @param columnaMaestro Nuevo valor de la propiedad columnaMaestro.
     */
    public void setColumnaMaestro(String columnaMaestro) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setColumnaMaestro(columnaMaestro);
        }
    }

    /**
     * Getter para propiedad columnaMaestroAnterior.
     *
     * @return Valor de la propiedad columnaMaestroAnterior.
     */
    public String getColumnaMaestroAnterior() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getColumnaMaestroAnterior();
    }

    /**
     * Setter para propiedad columnaMaestroAnterior.
     *
     * @param columnaMaestroAnterior Nuevo valor de la propiedad columnaMaestroAnterior.
     */
    public void setColumnaMaestroAnterior(String columnaMaestroAnterior) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setColumnaMaestroAnterior(columnaMaestroAnterior);
        }
    }

    /**
     * Getter para propiedad identificacionMaestro.
     *
     * @return Valor de la propiedad identificacionMaestro.
     */
    public Long getIdentificacionMaestro() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getIdentificacionMaestro();
    }

    /**
     * Setter para propiedad identificacionMaestro.
     *
     * @param identificacionMaestro Nuevo valor de la propiedad identificacionMaestro.
     */
    public void setIdentificacionMaestro(Long identificacionMaestro) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setIdentificacionMaestro(identificacionMaestro);
        }
    }

    /**
     * Getter para propiedad identificacionMaestroAnterior.
     *
     * @return Valor de la propiedad identificacionMaestroAnterior.
     */
    public Long getIdentificacionMaestroAnterior() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getIdentificacionMaestroAnterior();
    }

    /**
     * Setter para propiedad identificacionMaestroAnterior.
     *
     * @param identificacionMaestroAnterior Nuevo valor de la propiedad identificacionMaestroAnterior.
     */
    public void setIdentificacionMaestroAnterior(Long identificacionMaestroAnterior) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setIdentificacionMaestroAnterior(identificacionMaestroAnterior);
        }
    }

    /**
     * Getter para propiedad filasProcesadas.
     *
     * @return Valor de la propiedad filasProcesadas.
     */
    public Map getFilasProcesadas() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getFilasProcesadas();
    }

    public boolean esFilaProcesada(TableRowDataProvider tableRowDataProvider) {
        return tableRowDataProvider != null && esFilaProcesada(tableRowDataProvider.getTableRow());
    }

    public boolean esFilaProcesada(RowKey rowKey) {
        return rowKey != null && getFilasProcesadas().containsKey(rowKey.getRowId());
    }

    /**
     * Getter para propiedad filasRemovidas.
     *
     * @return Valor de la propiedad filasRemovidas.
     */
    public Map getFilasRemovidas() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getFilasRemovidas();
    }

    public boolean esFilaRemovida(TableRowDataProvider tableRowDataProvider) {
        return tableRowDataProvider != null && esFilaRemovida(tableRowDataProvider.getTableRow());
    }

    public boolean esFilaRemovida(RowKey rowKey) {
        return rowKey != null && getFilasRemovidas().containsKey(rowKey.getRowId());
    }

    /**
     * Conserva el valor de la propiedad filasPorConfirmar.
     */
    private int filasProcesadasPorConfirmar = 0;

    /**
     * Getter para propiedad filasPorConfirmar.
     *
     * @return Valor de la propiedad filasPorConfirmar.
     */
    protected int getFilasProcesadasPorConfirmar() {
        return filasProcesadasPorConfirmar;
    }

    /**
     * Getter para propiedad filasConflictivas.
     *
     * @return Valor de la propiedad filasConflictivas.
     */
    public Map getFilasConflictivas() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getFilasConflictivas();
    }

    public boolean esFilaConflictiva(TableRowDataProvider tableRowDataProvider) {
        return tableRowDataProvider != null && esFilaConflictiva(tableRowDataProvider.getTableRow());
    }

    public boolean esFilaConflictiva(RowKey rowKey) {
        return rowKey != null && getFilasConflictivas().containsKey(rowKey.getRowId());
    }

    /**
     * Getter para propiedad filasEliminadas.
     *
     * @return Valor de la propiedad filasEliminadas.
     */
    public int getFilasEliminadas() {
        return !isInicializado() ? 0 : getRecursoCachedRowSet().getFilasEliminadas();
    }

    /**
     * Setter para propiedad filasEliminadas.
     *
     * @param filasEliminadas Nuevo valor de la propiedad filasEliminadas.
     */
    protected void setFilasEliminadas(int filasEliminadas) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFilasEliminadas(filasEliminadas);
        }
    }

    protected int incrementaFilasEliminadas() {
        int i = getFilasEliminadas();
        setFilasEliminadas(++i);
        return getFilasEliminadas();
    }

    public Map<String, RastroFuncion> getRastrosFuncion() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getRastrosFuncion();
    }

    public Map<String, CampoBusqueda> getCamposBusqueda() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getCamposBusqueda();
    }

    public CampoBusqueda getCampoBusqueda(String campo) {
        return !isInicializado() || campo == null ? null : getRecursoCachedRowSet().getCamposBusqueda().get(campo);
    }

    public CampoBusqueda setCampoBusqueda(String campo, String columna, Object valor) {
        if (!isInicializado() || campo == null || columna == null) {
            return null;
        }
        Map<String, CampoBusqueda> camposBusqueda = getRecursoCachedRowSet().getCamposBusqueda();
        CampoBusqueda cb = camposBusqueda.get(campo);
        if (cb == null) {
            cb = new CampoBusqueda(columna);
        }
        cb.setValor(valor);
        return camposBusqueda.put(campo, cb);
    }

    /**
     * Getter para propiedad vistaFuncionSelect.
     *
     * @return Valor de la propiedad vistaFuncionSelect.
     */
    public Long getVistaFuncionSelect() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getVistaFuncionSelect();
    }

    /**
     * Setter para propiedad vistaFuncionSelect.
     *
     * @param vistaFuncionSelect Nuevo valor de la propiedad vistaFuncionSelect.
     */
    public void setVistaFuncionSelect(Long vistaFuncionSelect) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setVistaFuncionSelect(vistaFuncionSelect);
        }
    }

    /**
     * Getter para propiedad filtroFuncionSelect.
     *
     * @return Valor de la propiedad filtroFuncionSelect.
     */
    public Long getFiltroFuncionSelect() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getFiltroFuncionSelect();
    }

    /**
     * Setter para propiedad filtroFuncionSelect.
     *
     * @param filtroFuncionSelect Nuevo valor de la propiedad filtroFuncionSelect.
     */
    public void setFiltroFuncionSelect(Long filtroFuncionSelect) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFiltroFuncionSelect(filtroFuncionSelect);
        }
    }

    /**
     * Getter para propiedad filtroFuncionSelectAnterior.
     *
     * @return Valor de la propiedad filtroFuncionSelectAnterior.
     */
    public Long getFiltroFuncionSelectAnterior() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getFiltroFuncionSelectAnterior();
    }

    /**
     * Setter para propiedad filtroFuncionSelectAnterior.
     *
     * @param filtroFuncionSelectAnterior Nuevo valor de la propiedad filtroFuncionSelectAnterior.
     */
    public void setFiltroFuncionSelectAnterior(Long filtroFuncionSelectAnterior) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFiltroFuncionSelectAnterior(filtroFuncionSelectAnterior);
        }
    }

    /**
     * Getter para propiedad filtroFuncionSelectModificado.
     *
     * @return Valor de la propiedad filtroFuncionSelectModificado.
     */
    public boolean isFiltroFuncionSelectModificado() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFiltroFuncionSelectModificado();
    }
    //
    //  /**
    //   * Setter para propiedad filtroFuncionSelectModificado.
    //   *
    //   * @param filtroFuncionSelectModificado Nuevo valor de la propiedad filtroFuncionSelectModificado.
    //   */
    //  public void setFiltroFuncionSelectModificado(boolean filtroFuncionSelectModificado) {
    //      if (isInicializado()) {
    //          getRecursoCachedRowSet().setFiltroFuncionSelectModificado(filtroFuncionSelectModificado);
    //      }
    //  }

    /**
     * Getter para propiedad codigoFuncionSelect.
     *
     * @return Valor de la propiedad codigoFuncionSelect.
     */
    public String getCodigoFuncionSelect() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getCodigoFuncionSelect();
    }

    /**
     * Setter para propiedad codigoFuncionSelect.
     *
     * @param codigoFuncionSelect Nuevo valor de la propiedad codigoFuncionSelect.
     */
    public void setCodigoFuncionSelect(String codigoFuncionSelect) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setCodigoFuncionSelect(codigoFuncionSelect);
        }
    }

    /**
     * Getter para propiedad codigoFuncionSelectAnterior.
     *
     * @return Valor de la propiedad codigoFuncionSelectAnterior.
     */
    public String getCodigoFuncionSelectAnterior() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getCodigoFuncionSelectAnterior();
    }

    /**
     * Setter para propiedad codigoFuncionSelectAnterior.
     *
     * @param codigoFuncionSelectAnterior Nuevo valor de la propiedad codigoFuncionSelectAnterior.
     */
    public void setCodigoFuncionSelectAnterior(String codigoFuncionSelectAnterior) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setCodigoFuncionSelectAnterior(codigoFuncionSelectAnterior);
        }
    }

    /**
     * Getter para propiedad codigoFuncionSelectModificado.
     *
     * @return Valor de la propiedad codigoFuncionSelectModificado.
     */
    public boolean isCodigoFuncionSelectModificado() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isCodigoFuncionSelectModificado();
    }
    //
    //  /**
    //   * Setter para propiedad codigoFuncionSelectModificado.
    //   *
    //   * @param codigoFuncionSelectModificado Nuevo valor de la propiedad codigoFuncionSelectModificado.
    //   */
    //  public void setCodigoFuncionSelectModificado(boolean codigoFuncionSelectModificado) {
    //      if (isInicializado()) {
    //          getRecursoCachedRowSet().setCodigoFuncionSelectModificado(codigoFuncionSelectModificado);
    //      }
    //  }

    /**
     * Getter para propiedad nombreFuncionSelect.
     *
     * @return Valor de la propiedad nombreFuncionSelect.
     */
    public String getNombreFuncionSelect() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getNombreFuncionSelect();
    }

    /**
     * Setter para propiedad nombreFuncionSelect.
     *
     * @param nombreFuncionSelect Nuevo valor de la propiedad nombreFuncionSelect.
     */
    public void setNombreFuncionSelect(String nombreFuncionSelect) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setNombreFuncionSelect(nombreFuncionSelect);
        }
    }

    /**
     * Getter para propiedad nombreFuncionSelectAnterior.
     *
     * @return Valor de la propiedad nombreFuncionSelectAnterior.
     */
    public String getNombreFuncionSelectAnterior() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getNombreFuncionSelectAnterior();
    }

    /**
     * Setter para propiedad nombreFuncionSelectAnterior.
     *
     * @param nombreFuncionSelectAnterior Nuevo valor de la propiedad nombreFuncionSelectAnterior.
     */
    public void setNombreFuncionSelectAnterior(String nombreFuncionSelectAnterior) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setNombreFuncionSelectAnterior(nombreFuncionSelectAnterior);
        }
    }

    /**
     * Getter para propiedad nombreFuncionSelectModificado.
     *
     * @return Valor de la propiedad nombreFuncionSelectModificado.
     */
    public boolean isNombreFuncionSelectModificado() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isNombreFuncionSelectModificado();
    }
    //
    //  /**
    //   * Setter para propiedad nombreFuncionSelectModificado.
    //   *
    //   * @param nombreFuncionSelectModificado Nuevo valor de la propiedad nombreFuncionSelectModificado.
    //   */
    //  public void setNombreFuncionSelectModificado(boolean nombreFuncionSelectModificado) {
    //      if (isInicializado()) {
    //          getRecursoCachedRowSet().setNombreFuncionSelectModificado(nombreFuncionSelectModificado);
    //      }
    //  }

    /**
     * Getter para propiedad filtroFuncionSelect.
     *
     * @return Valor de la propiedad filtroFuncionSelect.
     */
    public Long getSegmentoFuncionSelect() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getSegmentoFuncionSelect();
    }

    /**
     * Setter para propiedad filtroFuncionSelect.
     *
     * @param filtroFuncionSelect Nuevo valor de la propiedad filtroFuncionSelect.
     */
    public void setSegmentoFuncionSelect(Long filtroFuncionSelect) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setSegmentoFuncionSelect(filtroFuncionSelect);
        }
    }

    /**
     * Getter para propiedad dominioSelect.
     *
     * @return Valor de la propiedad dominioSelect
     */
    public long getDominioSelect() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getDominioSelect();
    }

    /**
     * Setter para propiedad dominioSelect.
     *
     * @param dominioSelect Nuevo valor de la propiedad dominioSelect
     */
    public void setDominioSelect(long dominioSelect) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setDominioSelect(dominioSelect);
        }
    }

    /**
     * Getter para propiedad funcionSelect.
     *
     * @return Valor de la propiedad funcionSelect.
     */
    public long getFuncionSelect() {
        return !isInicializado() ? -1L : getRecursoCachedRowSet().getFuncionSelect();
    }

    /**
     * Setter para propiedad funcionSelect.
     *
     * @param funcionSelect Nuevo valor de la propiedad funcionSelect.
     */
    public void setFuncionSelect(long funcion) throws ExcepcionAplicacion {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionSelect(funcion);
        }
    }

    /**
     * Getter para propiedad funcionInsert.
     *
     * @return Valor de la propiedad funcionInsert.
     */
    public long getFuncionInsert() {
        return !isInicializado() ? -1L : getRecursoCachedRowSet().getFuncionInsert();
    }

    /**
     * Setter para propiedad funcionInsert.
     *
     * @param funcionInsert Nuevo valor de la propiedad funcionInsert.
     */
    public void setFuncionInsert(long funcion) throws ExcepcionAplicacion {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionInsert(funcion);
        }
    }

    /**
     * Getter para propiedad funcionUpdate.
     *
     * @return Valor de la propiedad funcionUpdate.
     */
    public long getFuncionUpdate() {
        return !isInicializado() ? -1L : getRecursoCachedRowSet().getFuncionUpdate();
    }

    /**
     * Setter para propiedad funcionUpdate.
     *
     * @param funcionUpdate Nuevo valor de la propiedad funcionUpdate.
     */
    public void setFuncionUpdate(long funcion) throws ExcepcionAplicacion {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionUpdate(funcion);
        }
    }

    /**
     * Getter para propiedad funcionDelete.
     *
     * @return Valor de la propiedad funcionDelete.
     */
    public long getFuncionDelete() {
        return !isInicializado() ? -1L : getRecursoCachedRowSet().getFuncionDelete();
    }

    /**
     * Setter para propiedad funcionDelete.
     *
     * @param funcionDelete Nuevo valor de la propiedad funcionDelete.
     */
    public void setFuncionDelete(long funcion) throws ExcepcionAplicacion {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionDelete(funcion);
        }
    }

    /**
     * Getter para propiedad funcionBusinessProcess.
     *
     * @return Valor de la propiedad funcionBusinessProcess.
     */
    public long getFuncionBusinessProcess() {
        return !isInicializado() ? -1L : getRecursoCachedRowSet().getFuncionBusinessProcess();
    }

    /**
     * Setter para propiedad funcionBusinessProcess.
     *
     * @param funcionBusinessProcess Nuevo valor de la propiedad funcionBusinessProcess.
     */
    public void setFuncionBusinessProcess(long funcion) throws ExcepcionAplicacion {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionBusinessProcess(funcion);
        }
    }

    /**
     * Getter para propiedad funcionSelectAutorizada.
     *
     * @return Valor de la propiedad funcionSelectAutorizada.
     */
    public boolean isFuncionSelectAutorizada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionSelectAutorizada();
    }

    /**
     * Getter para propiedad funcionInsertAutorizada.
     *
     * @return Valor de la propiedad funcionInsertAutorizada.
     */
    public boolean isFuncionInsertAutorizada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionInsertAutorizada();
    }

    /**
     * Getter para propiedad funcionUpdateAutorizada.
     *
     * @return Valor de la propiedad funcionUpdateAutorizada.
     */
    public boolean isFuncionUpdateAutorizada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionUpdateAutorizada();
    }

    /**
     * Getter para propiedad funcionDeleteAutorizada.
     *
     * @return Valor de la propiedad funcionDeleteAutorizada.
     */
    public boolean isFuncionDeleteAutorizada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionDeleteAutorizada();
    }

    /**
     * Getter para propiedad funcionBusinessProcessAutorizada.
     *
     * @return Valor de la propiedad funcionBusinessProcessAutorizada.
     */
    public boolean isFuncionBusinessProcessAutorizada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionBusinessProcessAutorizada();
    }

    /**
     * Getter para propiedad funcionSelectEjecutada.
     *
     * @return Valor de la propiedad funcionSelectEjecutada.
     */
    public boolean isFuncionSelectEjecutada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionSelectEjecutada();
    }

    /**
     * Setter para propiedad funcionSelectEjecutada.
     *
     * @param funcionSelectEjecutada Nuevo valor de la propiedad funcionSelectEjecutada.
     */
    protected void setFuncionSelectEjecutada(boolean funcionSelectEjecutada) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionSelectEjecutada(funcionSelectEjecutada);
        }
    }

    /**
     * Getter para propiedad funcionInsertEjecutada.
     *
     * @return Valor de la propiedad funcionInsertEjecutada.
     */
    public boolean isFuncionInsertEjecutada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionInsertEjecutada();
    }

    /**
     * Setter para propiedad funcionInsertEjecutada.
     *
     * @param funcionInsertEjecutada Nuevo valor de la propiedad funcionInsertEjecutada.
     */
    protected void setFuncionInsertEjecutada(boolean funcionInsertEjecutada) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionInsertEjecutada(funcionInsertEjecutada);
        }
    }

    /**
     * Getter para propiedad funcionUpdateEjecutada.
     *
     * @return Valor de la propiedad funcionUpdateEjecutada.
     */
    public boolean isFuncionUpdateEjecutada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionUpdateEjecutada();
    }

    /**
     * Setter para propiedad funcionUpdateEjecutada.
     *
     * @param funcionUpdateEjecutada Nuevo valor de la propiedad funcionUpdateEjecutada.
     */
    protected void setFuncionUpdateEjecutada(boolean funcionUpdateEjecutada) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionUpdateEjecutada(funcionUpdateEjecutada);
        }
    }

    /**
     * Getter para propiedad funcionDeleteEjecutada.
     *
     * @return Valor de la propiedad funcionDeleteEjecutada.
     */
    public boolean isFuncionDeleteEjecutada() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionDeleteEjecutada();
    }

    /**
     * Setter para propiedad funcionDeleteEjecutada.
     *
     * @param funcionDeleteEjecutada Nuevo valor de la propiedad funcionDeleteEjecutada.
     */
    protected void setFuncionDeleteEjecutada(boolean funcionDeleteEjecutada) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFuncionDeleteEjecutada(funcionDeleteEjecutada);
        }
    }

    /**
     * Getter para propiedad funcionBusinessProcessEjecutada.
     *
     * @return Valor de la propiedad funcionBusinessProcessEjecutada.
     */
    //  public boolean isFuncionBusinessProcessEjecutada() {
    //      return !isInicializado() ? false : getRecursoCachedRowSet().isFuncionBusinessProcessEjecutada();
    //  }
    //
    /**
     * Setter para propiedad funcionBusinessProcessEjecutada.
     *
     * @param funcionBusinessProcessEjecutada Nuevo valor de la propiedad funcionBusinessProcessEjecutada.
     */

    //  protected void setFuncionBusinessProcessEjecutada(boolean funcionBusinessProcessEjecutada) {
    //      if (isInicializado()) {
    //          getRecursoCachedRowSet().setFuncionBusinessProcessEjecutada(funcionBusinessProcessEjecutada);
    //      }
    //  }
    //
    /**
     * Getter para propiedad visorEscondido.
     *
     * @return Valor de la propiedad visorEscondido.
     */
    public boolean isVisorEscondido() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isVisorEscondido();
    }

    /**
     * Setter para propiedad visorEscondido.
     *
     * @param visorEscondido Nuevo valor de la propiedad visorEscondido.
     */
    public void setVisorEscondido(boolean visorEscondido) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setVisorEscondido(visorEscondido);
        }
    }

    /**
     * Getter para propiedad filtroAnulado.
     *
     * @return Valor de la propiedad filtroAnulado.
     */
    public boolean isFiltroAnulado() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFiltroAnulado();
    }

    /**
     * Setter para propiedad filtroAnulado.
     *
     * @param filtroAnulado Nuevo valor de la propiedad filtroAnulado.
     */
    public void setFiltroAnulado(boolean filtroAnulado) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFiltroAnulado(filtroAnulado);
        }
    }

    /**
     * Getter para propiedad filtroEscondido.
     *
     * @return Valor de la propiedad filtroEscondido.
     */
    public boolean isFiltroEscondido() {
        return !isInicializado() ? false : getRecursoCachedRowSet().isFiltroEscondido();
    }

    /**
     * Setter para propiedad filtroEscondido.
     *
     * @param filtroEscondido Nuevo valor de la propiedad filtroEscondido.
     */
    public void setFiltroEscondido(boolean filtroEscondido) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setFiltroEscondido(filtroEscondido);
        }
    }

    /**
     * Getter para propiedad versionComandoSelect.
     *
     * @return Valor de la propiedad versionComandoSelect.
     */
    public long getVersionComandoSelect() {
        return !isInicializado() ? -1L : getRecursoCachedRowSet().getVersionComandoSelect();
    }

    /**
     * Setter para propiedad versionComandoSelect.
     *
     * @param versionComandoSelect Nuevo valor de la propiedad versionComandoSelect.
     */
    protected void setVersionComandoSelect(long versionComandoSelect) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setVersionComandoSelect(versionComandoSelect);
        }
    }

    protected void incrementaVersionComandoSelect() {
        long i = getVersionComandoSelect();
        setVersionComandoSelect(++i);
    }

    /**
     * Getter para propiedad versionComandoSelectAnterior.
     *
     * @return Valor de la propiedad versionComandoSelectAnterior.
     */
    public long getVersionComandoSelectAnterior() {
        return !isInicializado() ? -1L : getRecursoCachedRowSet().getVersionComandoSelectAnterior();
    }

    /**
     * Setter para propiedad versionComandoSelectAnterior.
     *
     * @param versionComandoSelectAnterior Nuevo valor de la propiedad versionComandoSelectAnterior.
     */
    protected void setVersionComandoSelectAnterior(long versionComandoSelectAnterior) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setVersionComandoSelectAnterior(versionComandoSelectAnterior);
        }
    }

    /**
     * Getter para propiedad versionComandoInsert.
     *
     * @return Valor de la propiedad versionComandoInsert.
     */
    public long getVersionComandoInsert() {
        return !isInicializado() ? -1L : getRecursoCachedRowSet().getVersionComandoInsert();
    }

    /**
     * Setter para propiedad versionComandoInsert.
     *
     * @param versionComandoInsert Nuevo valor de la propiedad versionComandoInsert.
     */
    protected void setVersionComandoInsert(long versionComandoInsert) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setVersionComandoInsert(versionComandoInsert);
        }
    }

    /**
     * Getter para propiedad consultaBusqueda.
     *
     * @return Valor de la propiedad consultaBusqueda.
     */
    public String getConsultaBusqueda() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getConsultaBusqueda();
    }

    /**
     * Setter para propiedad consultaBusqueda.
     *
     * @param consultaBusqueda Nuevo valor de la propiedad consultaBusqueda.
     */
    public void setConsultaBusqueda(String consultaBusqueda) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setConsultaBusqueda(consultaBusqueda);
        }
    }

    /**
     * Setter para propiedad consultaBusqueda.
     *
     * @param consultaBusqueda Nuevo valor de la propiedad consultaBusqueda.
     */
    public void setConsultaBusqueda(ConsultaBusqueda consulta) {
        if (isInicializado()) {
            String consultaBusqueda = consulta == null ? null : consulta.getId();
            getRecursoCachedRowSet().setConsultaBusqueda(consultaBusqueda);
        }
    }

    /**
     * Getter para propiedad criteriosBusqueda.
     *
     * @return Valor de la propiedad criteriosBusqueda.
     */
    public String getCriteriosBusqueda() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getCriteriosBusqueda();
    }

    /**
     * Setter para propiedad criteriosBusqueda.
     *
     * @param criteriosBusqueda Nuevo valor de la propiedad criteriosBusqueda.
     */
    public void setCriteriosBusqueda(String criteriosBusqueda) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setCriteriosBusqueda(criteriosBusqueda);
        }
    }

    /**
     * Setter para propiedad criteriosBusqueda.
     *
     * @param criteriosBusqueda Nuevo valor de la propiedad criteriosBusqueda.
     */
    public void setCriteriosBusqueda(FiltroBusqueda filtro) {
        if (isInicializado()) {
            String criteriosBusqueda = filtro == null ? null : filtro.toString();
            getRecursoCachedRowSet().setCriteriosBusqueda(criteriosBusqueda);
        }
    }

    /**
     * Getter para propiedad criteriosOrden.
     *
     * @return Valor de la propiedad criteriosOrden.
     */
    public String getCriteriosOrden() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getCriteriosOrden();
    }

    /**
     * Setter para propiedad criteriosOrden.
     *
     * @param criteriosOrden Nuevo valor de la propiedad criteriosOrden.
     */
    public void setCriteriosOrden(String criteriosOrden) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setCriteriosOrden(criteriosOrden);
        }
    }

    /**
     * Setter para propiedad criteriosOrden.
     *
     * @param criteriosOrden Nuevo valor de la propiedad criteriosOrden.
     */
    public void setCriteriosOrden(OrdenConjuntoResultados orden) {
        if (isInicializado()) {
            String criteriosOrden = orden == null ? null : orden.toString();
            getRecursoCachedRowSet().setCriteriosOrden(criteriosOrden);
        }
    }

    /**
     * Getter para propiedad comandoSelectRestringido.
     *
     * @return Valor de la propiedad comandoSelectRestringido.
     */
    public String getComandoSelectRestringido() {
        String select = getComandoSelectAnsi();
        String columnas = getColumnasComandoSelectRestringido();
        int i = StringUtils.isBlank(columnas) ? -1 : StringUtils.indexOfIgnoreCase(select, " FROM ");
        return i < 0 ? select : "SELECT " + columnas + select.substring(i);
    }

    protected String getColumnasComandoSelectRestringido() {
        if (isFuncionSelectEjecutada()) {
            long funcion = getFuncionSelect();
            if (TLC.getControlador().esFuncionConParametrosRestringidos(funcion)) {
                String column;
                Long select;
                String dominio = getCodigoDominioRecurso();
                ArrayList<String> list = new ArrayList<>();
                List<String> columnas = getListaColumnasComandoSelect();
                for (String string : columnas) {
                    column = BaseBundle.getPropertyColumn(dominio, string);
                    select = BaseBundle.getPropertySelect(dominio, string);
                    if (column == null || select == null) {
                        list.add(string);
                    } else if (TLC.getControlador().esParametroAutorizado(column, select)) {
                        list.add(string);
                    } else {
                        list.add("NULL AS " + string);
                    }
                }
                String join = StringUtils.join(list, ", ");
                //              Bitacora.trace(join);
                return join;
            }
        }
        return null;
    }

    protected List<String> getListaColumnasComandoSelect() {
        ArrayList<String> list = new ArrayList<>();
        FieldKey[] keys = getFieldKeys();
        for (FieldKey key : keys) {
            list.add(key.getFieldId());
        }
        return list;
    }

    /**
     * Getter para propiedad comandoSelectAnsi.
     *
     * @return Valor de la propiedad comandoSelectAnsi.
     */
    public String getComandoSelectAnsi() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getComandoSelectAnsi();
    }

    /**
     * Setter para propiedad comandoSelectAnsi.
     *
     * @param comandoSelectAnsi Nuevo valor de la propiedad comandoSelectAnsi.
     */
    protected void setComandoSelectAnsi(String comandoSelectAnsi) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setComandoSelectAnsi(comandoSelectAnsi);
        }
    }

    /**
     * Getter para propiedad comandoSelectAnterior.
     *
     * @return Valor de la propiedad comandoSelectAnterior.
     */
    public String getComandoSelectAnterior() {
        return !isInicializado() ? null : getRecursoCachedRowSet().getComandoSelectAnterior();
    }

    /**
     * Setter para propiedad comandoSelectAnterior.
     *
     * @param comandoSelectAnterior Nuevo valor de la propiedad comandoSelectAnterior.
     */
    protected void setComandoSelectAnterior(String comandoSelectAnterior) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setComandoSelectAnterior(comandoSelectAnterior);
        }
    }

    /**
     * Getter para propiedad opcionZumNodo.
     *
     * @return Valor de la propiedad opcionZumNodo.
     */
    public EnumOpcionZumNodo getOpcionZumNodo() {
        return !isInicializado() ? EnumOpcionZumNodo.TODO : getRecursoCachedRowSet().getOpcionZumNodo();
    }

    /**
     * Setter para propiedad opcionZumNodo.
     *
     * @param opcionZumNodo Nuevo valor de la propiedad opcionZumNodo.
     */
    public void setOpcionZumNodo(EnumOpcionZumNodo opcionZumNodo) {
        if (isInicializado()) {
            getRecursoCachedRowSet().setOpcionZumNodo(opcionZumNodo);
        }
    }

    /**
     * Getter para propiedad consultaInsertDisponible.
     *
     * @return Valor de la propiedad consultaInsertDisponible.
     */
    public boolean isConsultaInsertDisponible() {
        return !isInicializado() ? false : getVersionComandoInsert() > 0L;
    }

    /**
     * Getter para propiedad consultaAnteriorDisponible.
     *
     * @return Valor de la propiedad consultaAnteriorDisponible.
     */
    public boolean isConsultaAnteriorDisponible() {
        return !isInicializado() ? false : getVersionComandoSelectAnterior() > 0L;
    }

    /**
     * Getter para propiedad funcionSelectHabilitada.
     *
     * @return Valor de la propiedad funcionSelectHabilitada.
     */
    public boolean isFuncionSelectHabilitada() {
        // boolean b = isFuncionSelectAutorizada();
        // int i = getFilasProcesadas().size() + getFilasEliminadas();
        // return b && i == 0;
        return isFuncionSelectAutorizada() && isLoteSinCambios();
    }

    /**
     * Getter para propiedad funcionInsertHabilitada.
     *
     * @return Valor de la propiedad funcionInsertHabilitada.
     */
    public boolean isFuncionInsertHabilitada() {
        // removeRow + appendRow + setCursorRow = java.lang.IllegalArgumentException
        // por lo tanto, hay que evitar el appendRow(con su consecuente setCursorRow) si se ejecuta un removeRow
        // boolean b = isFuncionInsertAutorizada();
        // int i = getFilasEliminadas();
        // return b && i == 0;
        // return isFuncionInsertAutorizada() && !isFuncionDeleteEjecutada();
        //      return isFuncionSelectEjecutada() && !isFuncionUpdateEjecutada() && !isFuncionDeleteEjecutada();
        return !isFuncionUpdateEjecutada() && !isFuncionDeleteEjecutada();
    }

    /**
     * Getter para propiedad funcionUpdateHabilitada.
     *
     * @return Valor de la propiedad funcionUpdateHabilitada.
     */
    public boolean isFuncionUpdateHabilitada() {
        // return isFuncionUpdateAutorizada() && isLoteConFilas();
        return isLoteConFilas() && !isFuncionInsertEjecutada() && !isFuncionDeleteEjecutada();
    }

    /**
     * Getter para propiedad funcionDeleteHabilitada.
     *
     * @return Valor de la propiedad funcionDeleteHabilitada.
     */
    public boolean isFuncionDeleteHabilitada() {
        // return isFuncionDeleteAutorizada() && isLoteConFilas();
        return isLoteConFilas() && !isFuncionInsertEjecutada() && !isFuncionUpdateEjecutada();
    }

    /**
     * Getter para propiedad funcionBusinessProcessHabilitada.
     *
     * @return Valor de la propiedad funcionBusinessProcessHabilitada.
     */
    public boolean isFuncionBusinessProcessHabilitada() {
        // return isFuncionBusinessProcessAutorizada() && isLoteConFilas();
        return isFuncionBusinessProcessAutorizada() && isLoteConFilas() && isLoteSinCambios();
    }

    /**
     * Getter para propiedad funcionHideViewerHabilitada.
     *
     * @return Valor de la propiedad funcionHideViewerHabilitada.
     */
    public boolean isFuncionHideViewerHabilitada() {
        return !isFuncionHideViewerInhabilitada();
    }

    /**
     * Getter para propiedad funcionHideViewerInhabilitada.
     *
     * @return Valor de la propiedad funcionHideViewerInhabilitada.
     */
    public boolean isFuncionHideViewerInhabilitada() {
        return isVisorEscondido();
    }

    /**
     * Getter para propiedad funcionShowViewerHabilitada.
     *
     * @return Valor de la propiedad funcionShowViewerHabilitada.
     */
    public boolean isFuncionShowViewerHabilitada() {
        String enabled = BaseBundle.getCurrentPageString("fragmento_visor_enabled");
        return BitUtils.valueOf(enabled) && isFuncionSelectEjecutada() && isVisorEscondido();
    }

    /**
     * Getter para propiedad funcionShowViewerInhabilitada.
     *
     * @return Valor de la propiedad funcionShowViewerInhabilitada.
     */
    public boolean isFuncionShowViewerInhabilitada() {
        return !isFuncionShowViewerHabilitada();
    }

    /**
     * Getter para propiedad funcionModifyViewerHabilitada.
     *
     * @return Valor de la propiedad funcionModifyViewerHabilitada.
     */
    public boolean isFuncionViewViewerHabilitada() {
        String enabled = BaseBundle.getCurrentPageString("fragmento_visor_enabled");
        return BitUtils.valueOf(enabled) && isFuncionSelectEjecutada() && !isVisorEscondido();
    }

    /**
     * Getter para propiedad funcionModifyViewerInhabilitada.
     *
     * @return Valor de la propiedad funcionModifyViewerInhabilitada.
     */
    public boolean isFuncionViewViewerInhabilitada() {
        return !isFuncionViewViewerHabilitada();
    }

    /**
     * Getter para propiedad funcionApplyViewerHabilitada.
     *
     * @return Valor de la propiedad funcionApplyViewerHabilitada.
     */
    public boolean isFuncionApplyViewerHabilitada() {
        return isFuncionSelectEjecutada();
    }

    /**
     * Getter para propiedad funcionApplyViewerInhabilitada.
     *
     * @return Valor de la propiedad funcionApplyViewerInhabilitada.
     */
    public boolean isFuncionApplyViewerInhabilitada() {
        return !isFuncionApplyViewerHabilitada();
    }

    /**
     * Getter para propiedad funcionHideFilterHabilitada.
     *
     * @return Valor de la propiedad funcionHideFilterHabilitada.
     */
    public boolean isFuncionHideFilterHabilitada() {
        return isFuncionSelectHabilitada() && isFuncionSelectEjecutada() && isCursorRowAvailable()
                && !isFiltroEscondido();
    }

    /**
     * Getter para propiedad funcionHideFilterInhabilitada.
     *
     * @return Valor de la propiedad funcionHideFilterInhabilitada.
     */
    public boolean isFuncionHideFilterInhabilitada() {
        return !isFuncionHideFilterHabilitada();
    }

    /**
     * Getter para propiedad funcionShowFilterHabilitada.
     *
     * @return Valor de la propiedad funcionShowFilterHabilitada.
     */
    public boolean isFuncionShowFilterHabilitada() {
        return isFuncionSelectHabilitada() && isFiltroEscondido();
    }

    /**
     * Getter para propiedad funcionShowFilterInhabilitada.
     *
     * @return Valor de la propiedad funcionShowFilterInhabilitada.
     */
    public boolean isFuncionShowFilterInhabilitada() {
        return !isFuncionShowFilterHabilitada();
    }

    /**
     * Getter para propiedad funcionModifyFilterHabilitada.
     *
     * @return Valor de la propiedad funcionModifyFilterHabilitada.
     */
    public boolean isFuncionViewFilterHabilitada() {
        return isFuncionSelectHabilitada() && !isFiltroEscondido();
    }

    /**
     * Getter para propiedad funcionModifyFilterInhabilitada.
     *
     * @return Valor de la propiedad funcionModifyFilterInhabilitada.
     */
    public boolean isFuncionViewFilterInhabilitada() {
        return !isFuncionViewFilterHabilitada();
    }

    /**
     * Getter para propiedad funcionApplyFilterHabilitada.
     *
     * @return Valor de la propiedad funcionApplyFilterHabilitada.
     */
    public boolean isFuncionApplyFilterHabilitada() {
        return isFuncionSelectHabilitada();
    }

    /**
     * Getter para propiedad funcionApplyFilterInhabilitada.
     *
     * @return Valor de la propiedad funcionApplyFilterInhabilitada.
     */
    public boolean isFuncionApplyFilterInhabilitada() {
        return !isFuncionApplyFilterHabilitada();
    }

    /**
     * Getter para propiedad funcionRemoveFilterHabilitada.
     *
     * @return Valor de la propiedad funcionRemoveFilterHabilitada.
     */
    public boolean isFuncionRemoveFilterHabilitada() {
        return isFuncionSelectHabilitada() && isFiltroFuncionSelectDisponible();
    }

    /**
     * Getter para propiedad funcionRemoveFilterInhabilitada.
     *
     * @return Valor de la propiedad funcionRemoveFilterInhabilitada.
     */
    public boolean isFuncionRemoveFilterInhabilitada() {
        return !isFuncionRemoveFilterHabilitada();
    }

    /**
     * Getter para propiedad funcionRestoreFilterHabilitada.
     *
     * @return Valor de la propiedad funcionRestoreFilterHabilitada.
     */
    public boolean isFuncionRestoreFilterHabilitada() {
        return isFuncionSelectHabilitada() && isFiltroFuncionSelectAnteriorDisponible();
    }

    /**
     * Getter para propiedad funcionRestoreFilterInhabilitada.
     *
     * @return Valor de la propiedad funcionRestoreFilterInhabilitada.
     */
    public boolean isFuncionRestoreFilterInhabilitada() {
        return !isFuncionRestoreFilterHabilitada();
    }

    /**
     * Getter para propiedad filtroFuncionSelectDisponible.
     *
     * @return Valor de la propiedad filtroFuncionSelectDisponible.
     */
    private boolean isFiltroFuncionSelectDisponible() {
        return (hayCamposBusquedaDisponibles() || getFiltroFuncionSelect() != null
                || getCodigoFuncionSelect() != null || getNombreFuncionSelect() != null);
    }

    /**
     * Getter para propiedad filtroFuncionSelectAnteriorDisponible.
     *
     * @return Valor de la propiedad filtroFuncionSelectAnteriorDisponible.
     */
    private boolean isFiltroFuncionSelectAnteriorDisponible() {
        return (hayCamposBusquedaAnterioresDisponibles() || getFiltroFuncionSelectAnterior() != null
                || getCodigoFuncionSelectAnterior() != null || getNombreFuncionSelectAnterior() != null);
    }

    private boolean hayCamposBusquedaDisponibles() {
        Map<String, CampoBusqueda> camposBusqueda = getCamposBusqueda();
        if (camposBusqueda == null) {
            return false;
        }
        for (CampoBusqueda campo : camposBusqueda.values()) {
            if (campo.getValor() != null) {
                return true;
            }
        }
        return false;
    }

    private boolean hayCamposBusquedaAnterioresDisponibles() {
        Map<String, CampoBusqueda> camposBusqueda = getCamposBusqueda();
        if (camposBusqueda == null) {
            return false;
        }
        for (CampoBusqueda campo : camposBusqueda.values()) {
            if (campo.getValorAnterior() != null) {
                return true;
            }
        }
        return false;
    }

    /**
     * Getter para propiedad loteConFilas.
     *
     * @return Valor de la propiedad loteConFilas.
     */
    public boolean isLoteConFilas() {
        //      return isInicializado() && getRowCount() > 0;
        return isInicializado() && getRowKeys(1, null).length > 0;
    }

    /**
     * Getter para propiedad loteSinFilas.
     *
     * @return Valor de la propiedad loteSinFilas.
     */
    public boolean isLoteSinFilas() {
        return !isLoteConFilas();
    }

    /**
     * Getter para propiedad loteConCambios.
     *
     * @return Valor de la propiedad loteConCambios.
     */
    public boolean isLoteConCambios() {
        return isFuncionInsertEjecutada() || isFuncionUpdateEjecutada() || isFuncionDeleteEjecutada();
    }

    /**
     * Getter para propiedad loteSinCambios.
     *
     * @return Valor de la propiedad loteSinCambios.
     */
    public boolean isLoteSinCambios() {
        return !isLoteConCambios();
    }

    /**
     * Getter para propiedad loteConFilasEliminadas.
     *
     * @return Valor de la propiedad loteConFilasEliminadas.
     */
    public boolean isLoteConFilasEliminadas() {
        int i = !isInicializado() ? 0 : getFilasEliminadas();
        return i > 0;
    }

    /**
     * Getter para propiedad loteSinFilasEliminadas.
     *
     * @return Valor de la propiedad loteSinFilasEliminadas.
     */
    public boolean isLoteSinFilasEliminadas() {
        return !isLoteConFilasEliminadas();
    }

    /**
     * Getter para propiedad cursorRowAvailable.
     *
     * @return Valor de la propiedad cursorRowAvailable.
     */
    public boolean isCursorRowAvailable() {
        if (isInicializado()) {
            try {
                RowKey rowKey = getCursorRow();
                return isRowAvailable(rowKey);
            } catch (Exception ex) {
            }
        }
        return false;
    }

    /**
     * Getter para propiedad filaEscogidaDisponible.
     *
     * @return Valor de la propiedad filaEscogidaDisponible.
     */
    public boolean isFilaEscogidaDisponible() {
        if (isInicializado()) {
            try {
                RowKey rowKey = getFilaEscogida();
                return isRowAvailable(rowKey);
            } catch (Exception ex) {
            }
        }
        return false;
    }

    /**
     * Conserva el valor de la propiedad idDominioRecurso.
     */
    private static final long ID_DOMINIO_RECURSO = -1L;

    /**
     * Getter para propiedad idDominioRecurso.
     *
     * @return Valor de la propiedad idDominioRecurso.
     */
    public long getIdDominioRecurso() {
        return ID_DOMINIO_RECURSO;
    }

    /**
     * Conserva el valor de la propiedad codigoDominioRecurso.
     */
    private static final String CODIGO_DOMINIO_RECURSO = DB.DOMINIO_RECURSO;

    /**
     * Getter para propiedad codigoDominioRecurso.
     *
     * @return Valor de la propiedad codigoDominioRecurso.
     */
    public String getCodigoDominioRecurso() {
        return CODIGO_DOMINIO_RECURSO;
    }

    /**
     * Conserva el valor de la propiedad nombreDominioRecurso.
     */
    private static final String NOMBRE_DOMINIO_RECURSO = "Recursos";

    /**
     * Getter para propiedad nombreDominioRecurso.
     *
     * @return Valor de la propiedad nombreDominioRecurso.
     */
    public String getNombreDominioRecurso() {
        return NOMBRE_DOMINIO_RECURSO;
    }

    /**
     * Conserva el valor de la propiedad comandoSelect.
     */
    private static final String COMANDO_SELECT = "SELECT * FROM " + DB.DOMINIO_RECURSO + " ";

    /**
     * Getter para propiedad comandoSelect.
     *
     * @return Valor de la propiedad comandoSelect.
     */
    public String getComandoSelect() {
        return COMANDO_SELECT;
    }

    /**
     * Conserva el valor de la propiedad comandoSelectNothing.
     */
    private static final String COMANDO_SELECT_NOTHING = COMANDO_SELECT + "WHERE (0=1)";

    /**
     * Getter para propiedad comandoSelectNothing.
     *
     * @return Valor de la propiedad comandoSelectNothing.
     */
    public String getComandoSelectNothing() {
        return COMANDO_SELECT_NOTHING;
    }

    /**
     * Conserva el valor de la propiedad tablaDestino.
     */
    private static final String TABLA_DESTINO = CODIGO_DOMINIO_RECURSO;

    /**
     * Getter para propiedad tablaDestino.
     *
     * @return Valor de la propiedad tablaDestino.
     */
    public String getTablaDestino() {
        return TABLA_DESTINO;
    }

    /**
     * Getter para propiedad etiquetaRecurso.
     *
     * @return Valor de la propiedad etiquetaRecurso.
     */
    public String getEtiquetaRecurso() {
        return !isInicializado() ? null : getEtiquetaRecurso(getCursorRow());
    }

    /**
     * Getter para propiedad etiquetaRecurso.
     *
     * @return Valor de la propiedad etiquetaRecurso.
     */
    public String getEtiquetaRecurso(RowKey rowKey) {
        Integer id = Integer.valueOf(rowKey.getRowId());
        String tag = Global.PREFIJO_ETIQUETA_ID_RECURSO + String.valueOf(id + 1);
        return tag;
    }

    /**
     * Getter para propiedad denominacionFilaEscogida.
     *
     * @return Valor de la propiedad denominacionFilaEscogida.
     */
    public String getDenominacionFilaEscogida() {
        return getDenominacionFilaEscogida(null);
    }

    /**
     * Getter para propiedad denominacionFilaEscogida.
     *
     * @return Valor de la propiedad denominacionFilaEscogida.
     */
    public String getDenominacionFilaEscogida(String etiqueta) {
        String tag1 = StringUtils.trimToEmpty(etiqueta);
        String tag2 = null;
        if (isInicializado()) { /* DTR (design-time-requirement) */
            RowKey rowKey = getFilaEscogida();
            if (isRowAvailable(rowKey)) {
                String quotes = StringUtils.isBlank(tag1) ? "" : "\"";
                String nosym1 = StringUtils.isBlank(tag1) ? "" : "N\272 ";
                String nosym2 = StringUtils.isBlank(tag1) ? "" : "#";
                String codigo = null;
                String numero = null;
                String serial = null;
                String nombre = null;
                String cognom = null;
                if (isRecursoCodificable()) {
                    String string = getRecursoCodificableDataProvider().getCodigoRecurso(rowKey);
                    codigo = StringUtils.isBlank(string) ? null : quotes + string + quotes;
                }
                if (isRecursoEnumerable()) {
                    Integer number = getRecursoEnumerableDataProvider().getNumeroRecurso(rowKey);
                    numero = number == null ? null : nosym1 + number;
                }
                if (isRecursoIdentificable()) {
                    Long number = getRecursoIdentificableDataProvider().getIdentificacionRecurso(rowKey);
                    serial = number == null ? null : nosym2 + number;
                }
                if (isRecursoNombrable()) {
                    String string = getRecursoNombrableDataProvider().getNombreRecurso(rowKey);
                    nombre = StringUtils.isBlank(string) ? null : quotes + string + quotes;
                    cognom = nombre == null ? null : " (" + string + ")";
                }
                tag2 = codigo != null ? codigo : numero != null ? numero : serial != null ? serial : null;
                tag2 = nombre == null ? tag2
                        : tag2 == null ? nombre : tag2.equalsIgnoreCase(nombre) ? tag2 : tag2 + cognom;
            }
        }
        return StringUtils.isBlank(tag2) ? tag1 : StringUtils.isBlank(tag1) ? tag2 : tag1 + " " + tag2;
    }

    /**
     * Getter para propiedad mensajeCambiosPorConfirmar.
     *
     * @return Valor de la propiedad mensajeCambiosPorConfirmar.
     */
    public String getMensajeCambiosPorConfirmar() {
        if (!isInicializado()) {
            return null;
        }
        String clave = CBM.CHANGES_TO_COMMIT;
        int i = getFilasProcesadas().size();
        int j = getFilasEliminadas();
        return i > 0 || j > 0 ? Bitacora.getTextoMensaje(clave, Integer.valueOf(i), Integer.valueOf(j)) : null;
    }

    /**
     * Getter para propiedad mensajeCambiosPorDescartar.
     *
     * @return Valor de la propiedad mensajeCambiosPorDescartar.
     */
    public String getMensajeCambiosPorDescartar() {
        if (!isInicializado()) {
            return null;
        }
        String clave = CBM.CHANGES_TO_REVERT;
        int i = getFilasProcesadas().size();
        int j = getFilasEliminadas();
        return i > 0 || j > 0 ? Bitacora.getTextoMensaje(clave, Integer.valueOf(i), Integer.valueOf(j)) : null;
    }

    /**
     * Conserva el valor de la propiedad mensajeErrorFinal.
     */
    private String mensajeErrorFinal;

    /**
     * Conserva el valor de la propiedad mensajeAdvertenciaFinal.
     */
    private String mensajeAdvertenciaFinal;

    /**
     * Conserva el valor de la propiedad mensajeInformativoFinal.
     */
    private String mensajeInformativoFinal;

    private void darMensajeFinal() {
        if (mensajeErrorFinal != null) {
            TLC.getBitacora().error(mensajeErrorFinal);
        }
        if (mensajeAdvertenciaFinal != null) {
            TLC.getBitacora().warn(mensajeAdvertenciaFinal);
        }
        if (mensajeInformativoFinal != null) {
            TLC.getBitacora().info(mensajeInformativoFinal);
        }
        resetMensajesFinales();
    }

    private void resetMensajesFinales() {
        mensajeErrorFinal = null;
        mensajeAdvertenciaFinal = null;
        mensajeInformativoFinal = null;
    }

    /**
     * Conserva el valor de la propiedad limiteFilasFuncionSelect.
     */
    private int limiteFilasFuncionSelect = 0;

    /**
     * Getter para propiedad limiteFilasFuncionSelect.
     *
     * @return Valor de la propiedad limiteFilasFuncionSelect.
     */
    public int getLimiteFilasFuncionSelect() {
        return limiteFilasFuncionSelect;
    }

    /**
     * Setter para propiedad limiteFilasFuncionSelect.
     *
     * @param limiteFilasFuncionSelect Nuevo valor de la propiedad limiteFilasFuncionSelect.
     */
    public void setLimiteFilasFuncionSelect(int limiteFilasFuncionSelect) {
        this.limiteFilasFuncionSelect = limiteFilasFuncionSelect;
    }

    public String getDataSourceCachedRowSet() {
        CachedRowSet crs = getCachedRowSet();
        return crs == null ? "" : crs.getDataSourceName();
    }

    protected void setDataSourceCachedRowSet(String dataSource) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "setDataSourceCachedRowSet", dataSource);
        if (StringUtils.isNotBlank(dataSource)) {
            CachedRowSet crs = getCachedRowSet();
            Bitacora.trace(getClass(), "setDataSourceCachedRowSet",
                    crs == null ? "CachedRowSet=?" : "CachedRowSet=" + crs);
            if (crs != null && !dataSource.equalsIgnoreCase(crs.getDataSourceName())) {
                try {
                    crs.setDataSourceName(dataSource); /* throws SQLException */
                } catch (SQLException ex) {
                    TLC.getBitacora().fatal(ex);
                    throw new ExcepcionAplicacion(ex);
                }
            }
        }
    }

    public String getComandoCachedRowSet() {
        CachedRowSet crs = getCachedRowSet();
        return crs == null ? "" : crs.getCommand();
    }

    protected void setComandoCachedRowSet(String comando) throws ExcepcionAplicacion {
        if (EA.isLoaded() && StringUtils.isBlank(getDataSourceCachedRowSet())) {
            setDataSourceCachedRowSet(EA.getString(EAC.JDBC_DATASOURCE));
        }
        setComandoCachedRowSet(comando, false);
    }

    protected void setComandoCachedRowSet(String comando, boolean refresh) throws ExcepcionAplicacion {
        setComandoCachedRowSet(comando, refresh, 0L);
    }

    private void setComandoCachedRowSet(String comando, boolean refresh, long version) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "setComandoCachedRowSet", comando, "refresh=" + refresh);
        if (StringUtils.isNotBlank(comando)) {
            CachedRowSet crs = getCachedRowSet();
            Bitacora.trace(getClass(), "setComandoCachedRowSet",
                    crs == null ? "CachedRowSet=?" : "CachedRowSet=" + crs);
            if (crs != null) {
                try {
                    InterpreteSql interprete = TLC.getInterpreteSql();
                    if (interprete != null) {
                        String command = crs.getCommand();
                        String comandoSelect = interprete.getComandoSelect(comando, getLimiteFilasFuncionSelect());
                        if (comandoSelect != null && !comandoSelect.equals(command)) {
                            crs.setCommand(comandoSelect); /* throws SQLException */
                            setComandoSelectAnsi(comando);
                            incrementaVersionComandoSelect();
                            setVersionComandoInsert(version);
                        }
                        if (refresh) {
                            refresh(); /* throws DataProviderException */
                        }
                    }
                } catch (SQLException | DataProviderException ex) {
                    TLC.getBitacora().fatal(ex);
                    throw new ExcepcionAplicacion(ex);
                }
            }
        }
    }

    public String getTablaCachedRowSet() throws SQLException {
        CachedRowSet crs = getCachedRowSet();
        return crs == null ? "" : crs.getTableName();
    }

    protected void setTablaCachedRowSet(String tabla) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "setTablaCachedRowSet", tabla);
        if (StringUtils.isNotBlank(tabla)) {
            CachedRowSet crs = getCachedRowSet();
            Bitacora.trace(getClass(), "setTablaCachedRowSet",
                    crs == null ? "CachedRowSet=?" : "CachedRowSet=" + crs);
            if (crs != null) {
                try {
                    InterpreteSql interprete = TLC.getInterpreteSql();
                    if (interprete != null) {
                        String tableName = crs.getTableName(); /* throws SQLException */
                        String nombreTabla = interprete.getNombreTabla(tabla);
                        if (nombreTabla != null && !nombreTabla.equals(tableName)) {
                            crs.setTableName(nombreTabla); /* throws SQLException */
                        }
                    }
                } catch (SQLException ex) {
                    TLC.getBitacora().fatal(ex);
                    throw new ExcepcionAplicacion(ex);
                }
            }
        }
    }

    protected void setColumnasInsertables(boolean insertable) {
        CachedRowSet crs = getCachedRowSet();
        if (crs instanceof CachedRowSetX) {
            FieldKey[] keys = getFieldKeys();
            if (keys != null && keys.length > 0) {
                CachedRowSetX crsx = (CachedRowSetX) crs;
                boolean[] columns = crsx.getInsertableColumns();
                if (columns != null) {
                    int colcount = columns.length;
                    if (keys.length != colcount) {
                        columns = new boolean[keys.length];
                    }
                    for (int i = 0; i < columns.length; i++) {
                        columns[i] = insertable;
                    }
                    crsx.setInsertableColumns(columns);
                }
            }
        }
    }

    protected void setColumnasInsertables(String columna, boolean insertable) {
        CachedRowSet crs = getCachedRowSet();
        if (crs instanceof CachedRowSetX) {
            FieldKey[] keys = getFieldKeys();
            if (keys != null && keys.length > 0) {
                CachedRowSetX crsx = (CachedRowSetX) crs;
                boolean[] columns = crsx.getInsertableColumns();
                int colcount = columns == null ? 0 : columns.length;
                if (keys.length != colcount) {
                    columns = new boolean[keys.length];
                    for (int i = 0; i < columns.length; i++) {
                        columns[i] = false;
                    }
                    crsx.setInsertableColumns(columns);
                }
                for (int i = 0; i < keys.length; i++) {
                    if (columna.equalsIgnoreCase(keys[i].getDisplayName())) {
                        crsx.setInsertableColumns(i, insertable);
                    }
                }
            }
        }
    }

    protected void setColumnasModificables(boolean modificable) {
        CachedRowSet crs = getCachedRowSet();
        if (crs instanceof CachedRowSetX) {
            FieldKey[] keys = getFieldKeys();
            if (keys != null && keys.length > 0) {
                CachedRowSetX crsx = (CachedRowSetX) crs;
                boolean[] columns = crsx.getUpdatableColumns();
                if (columns != null) {
                    int colcount = columns.length;
                    if (keys.length != colcount) {
                        columns = new boolean[keys.length];
                    }
                    for (int i = 0; i < columns.length; i++) {
                        columns[i] = modificable;
                    }
                    crsx.setUpdatableColumns(columns);
                }
            }
        }
    }

    protected void setColumnasModificables(String columna, boolean modificable) {
        CachedRowSet crs = getCachedRowSet();
        if (crs instanceof CachedRowSetX) {
            FieldKey[] keys = getFieldKeys();
            if (keys != null && keys.length > 0) {
                CachedRowSetX crsx = (CachedRowSetX) crs;
                boolean[] columns = crsx.getUpdatableColumns();
                int colcount = columns == null ? 0 : columns.length;
                if (keys.length != colcount) {
                    columns = new boolean[keys.length];
                    for (int i = 0; i < columns.length; i++) {
                        columns[i] = false;
                    }
                    crsx.setUpdatableColumns(columns);
                }
                for (int i = 0; i < keys.length; i++) {
                    if (columna.equalsIgnoreCase(keys[i].getDisplayName())) {
                        crsx.setUpdatableColumns(i, modificable);
                    }
                }
            }
        }
    }

    public boolean isColumnaInsertable(String columna) {
        CachedRowSet crs = getCachedRowSet();
        if (crs instanceof CachedRowSetX) {
            FieldKey[] keys = getFieldKeys();
            if (keys == null || keys.length == 0) {
                return false;
            }
            CachedRowSetX crsx = (CachedRowSetX) crs;
            boolean[] columns = crsx.getInsertableColumns();
            if (columns == null || columns.length == 0 || columns.length != keys.length) {
                return false;
            }
            for (int i = 0; i < keys.length; i++) {
                if (columna.equalsIgnoreCase(keys[i].getDisplayName())) {
                    return columns[i];
                }
            }
        }
        return false;
    }

    public boolean isColumnaModificable(String columna) {
        CachedRowSet crs = getCachedRowSet();
        if (crs instanceof CachedRowSetX) {
            FieldKey[] keys = getFieldKeys();
            if (keys == null || keys.length == 0) {
                return false;
            }
            CachedRowSetX crsx = (CachedRowSetX) crs;
            boolean[] columns = crsx.getUpdatableColumns();
            if (columns == null || columns.length == 0 || columns.length != keys.length) {
                return false;
            }
            for (int i = 0; i < keys.length; i++) {
                if (columna.equalsIgnoreCase(keys[i].getDisplayName())) {
                    return columns[i];
                }
            }
        }
        return false;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a la Lista de Opciones">
    public ArrayList getListaOpciones() {
        return getListaOpciones(false, EnumColumnaEtiqueta.AMBAS_COLUMNAS, true);
    }

    public ArrayList getListaOpciones(boolean anulable) {
        return getListaOpciones(anulable, EnumColumnaEtiqueta.AMBAS_COLUMNAS, true);
    }

    public ArrayList getListaOpciones(boolean anulable, String columna) {
        return getListaOpciones(anulable, columna, true);
    }

    public ArrayList getListaOpciones(boolean anulable, EnumColumnaEtiqueta columna) {
        return getListaOpciones(anulable, columna, true);
    }

    public ArrayList getListaOpciones(boolean anulable, boolean ordenado) {
        return getListaOpciones(anulable, EnumColumnaEtiqueta.AMBAS_COLUMNAS, ordenado);
    }

    public ArrayList getListaOpciones(String columna) {
        return getListaOpciones(false, columna, true);
    }

    public ArrayList getListaOpciones(EnumColumnaEtiqueta columna) {
        return getListaOpciones(false, columna, true);
    }

    public ArrayList getListaOpciones(String columna, boolean ordenado) {
        return getListaOpciones(false, columna, ordenado);
    }

    public ArrayList getListaOpciones(EnumColumnaEtiqueta columna, boolean ordenado) {
        return getListaOpciones(false, columna, ordenado);
    }

    public ArrayList getListaOpciones(boolean anulable, String columna, boolean ordenado) {
        return JSF.getListaOpciones(this, anulable, columna, ordenado);
    }

    public ArrayList getListaOpciones(boolean anulable, EnumColumnaEtiqueta columna, boolean ordenado) {
        return JSF.getListaOpciones(this, anulable, columna, ordenado);
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a la Etiqueta de la Transaccion">
    public String getEtiquetaTransaccion(RowKey rowKey) throws SQLException {
        if (isInicializado()) {
            setCursorRow(rowKey); /* throws TableCursorVetoException */
            return getEtiquetaTransaccion();
        }
        return null;
    }

    public String getEtiquetaTransaccion() throws SQLException {
        if (isInicializado()) {
            CachedRowSet crs = getCachedRowSet();
            if (crs == null) {
                return null;
            } else if (crs.rowInserted()) {
                return BundleWebui.getString("database.insert.command");
            } else if (crs.rowUpdated()) {
                return BundleWebui.getString("database.update.command");
            } else if (crs.rowDeleted()) {
                return BundleWebui.getString("database.delete.command");
            } else {
                return BundleWebui.getString("database.commit.command");
            }
        }
        return null;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a appendRow">
    /**
     * {@inheritDoc}
     */
    @Override
    public RowKey appendRow() throws DataProviderException {
        return appendRow(getFuncionInsert());
    }

    public RowKey appendRow(long funcion) throws DataProviderException {
        Bitacora.trace(getClass(), "appendRow", funcion);
        try {
            if (isFuncionUpdateEjecutada() || isFuncionDeleteEjecutada()) {
                throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.INSERT_ROW_EXCEPTION_4));
            }
            setFuncionInsert(funcion); /* throws ExcepcionAplicacion */
            if (esPermitidoAgregar()) {
                setComandoSelectVersion(); /* throws ExcepcionAplicacion */
                RowKey rowKey = super.appendRow(); /* throws DataProviderException */
                setFuncionInsertEjecutada(true);
                getFilasProcesadas().put(rowKey.getRowId(), rowKey);
                posAppendRow(rowKey, funcion); /* fire afterAppendRow event? */
                setAppendedRowVersion(rowKey);
                setFilaEscogida(rowKey);
                return rowKey;
            }
            String message = getBeforeAppendingProcedureDefaultErrorMessage();
            if (message != null) {
                TLC.getBitacora().error(message);
            }
            String transaction = DBUtils.getTransactionLabel(SyncResolver.INSERT_ROW_CONFLICT);
            TLC.getBitacora().error(CBM.FUNCION_NO_DISPONIBLE, transaction, "");
            return null;
        } catch (ExcepcionAplicacion ex) {
            throw new DataProviderException(ex);
        } catch (DataProviderException ex) {
            TLC.getBitacora().fatal(ex);
            throw ex;
        }
    }

    protected boolean esPermitidoAgregar() {
        Bitacora.trace(getClass(), "esPermitidoAgregar");
        Object object = execute(getBeforeAppendingProcedure(), getIdentificacionMaestro());
        return object instanceof Exception ? false : object == null || BitUtils.valueOf(object);
    }
    //
    //    protected boolean esFilaInsertable(RowKey rowKey, long funcion) {
    //        Bitacora.trace(getClass(), "esFilaInsertable", rowKey, funcion);
    //        return isRowAvailable(rowKey)
    //            && esFilaRecursoActivo(rowKey, funcion)
    //            && esFilaRecursoAutorizado(rowKey, funcion);
    //    }

    protected void setComandoSelectVersion() throws ExcepcionAplicacion {
        if (isRecursoVersionable() && getVersionComandoInsert() == 0L) {
            String columnaId = getRecursoVersionableDataProvider().getColumnaIdentificacionRecurso();
            String columnaVersion = getRecursoVersionableDataProvider().getColumnaVersionRecurso();
            long version = LongUtils.getNewId();
            FiltroBusqueda filtro = new FiltroBusqueda();
            filtro.addCriterio(columnaVersion, OperadorComEnumeration.ES_IGUAL, version);
            String comando = getComandoSelect();
            comando += "WHERE " + filtro.toString() + " ";
            comando += "ORDER BY " + columnaId + " ";
            setComandoCachedRowSet(comando, true, version);
            resetFilter();
        }
    }

    protected void posAppendRow(RowKey rowKey, long funcion) {
        /* fire afterAppendRow event? */
        Bitacora.trace(getClass(), "posAppendRow", rowKey, funcion);
    }

    protected void setAppendedRowVersion(RowKey rowKey) {
        if (isRecursoVersionable()) {
            getRecursoVersionableDataProvider().setVersionRecurso(rowKey, getVersionComandoInsert());
        }
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a editRow">
    public void recursoCachedRowSetDataProvider_valueChanged(TableDataProvider tdp, FieldKey fk, RowKey rk,
            Object o3, Object o4) {
        // o3 es el valor original y o4 es el nuevo
        Bitacora.trace(getClass(), "valueChanged", fk.getDisplayName() + "(" + rk.getRowId() + ")", o3, o4);
        //
        // CachedRowSetX crsx = (CachedRowSetX) getCachedRowSet();
        // FieldKey[] fieldKeys = getFieldKeys();
        // int columnsUpdated = 0;
        // for (int i = 0; i < fieldKeys.length; i++)
        //     if (crsx.columnUpdated(fieldKeys[i].getDisplayName()))
        //         columnsUpdated++;
        //
        try {
            setCursorRow(rk); /* throws TableCursorVetoException */
            if (getFilasProcesadas().containsKey(rk.getRowId())) {
                setFilaEscogida(rk); /* fila recion insertada o ya editada */
            } else {
                String texto = Bitacora.getTextoMensaje(CBM.CHECK_CHANGES_EXCEPTION_3, getEtiquetaRecurso(rk));
                //              boolean b = TLC.getBitacora().isSinDuplicados();
                //              TLC.getBitacora().setSinDuplicados(true);
                //              TLC.getBitacora().error(texto);
                //              TLC.getBitacora().setSinDuplicados(b);
                throw new ExcepcionAplicacion(texto);
            }
        } catch (TableCursorVetoException ex) {
            TLC.getBitacora().fatal(ex); /* throw new DataProviderException(ex); */
        } catch (ExcepcionAplicacion ex) {
            try {
                getCachedRowSet().cancelRowUpdates(); /* throws SQLException */
            } catch (SQLException sqlex) {
                TLC.getBitacora().fatal(sqlex); /* throw new DataProviderException(sqlex); */
            }
        }
    }

    public boolean editRow(RowKey rowKey) throws ExcepcionAplicacion {
        return editRow(rowKey, getFuncionUpdate());
    }

    public boolean editRow(Set rowSet) throws ExcepcionAplicacion {
        return editRow(rowSet, getFuncionUpdate());
    }

    public boolean editRow(Set rowSet, long funcion) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "editRow", funcion);
        setFuncionUpdate(funcion); /* throws ExcepcionAplicacion */
        if (rowSet.isEmpty()) {
            TLC.getBitacora().warn(CBM.UPDATE_NONE);
            return false;
        }
        boolean edited = false;
        resetMensajesFinales();
        mensajeAdvertenciaFinal = CBM.UPDATE_NONE;
        Iterator iterator = rowSet.iterator();
        while (iterator.hasNext()) {
            RowKey rowKey = (RowKey) iterator.next();
            edited |= editRow(rowKey, funcion); /* throws ExcepcionAplicacion */
        }
        darMensajeFinal();
        return edited;
    }

    public boolean editRow(RowKey rowKey, long funcion) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "editRow", rowKey, funcion);
        try {
            boolean edited = false;
            if (isRowAvailable(rowKey)) {
                setCursorRow(rowKey); /* throws SQLException */
                if (getFilasProcesadas().containsKey(rowKey.getRowId())) {
                    return false; /* fila recion insertada o ya editada */
                }
                if (getCachedRowSet().rowDeleted() || getCachedRowSet().rowInserted()) { /* throws SQLException */
                    throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.UPDATE_ROW_EXCEPTION_3));
                }
                if (isFuncionInsertEjecutada() || isFuncionDeleteEjecutada()) {
                    throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.UPDATE_ROW_EXCEPTION_4));
                }
                setFuncionUpdate(funcion); /* throws ExcepcionAplicacion */
                if (esPermitidoEditar(rowKey)) {
                    if (esFilaModificable(rowKey, funcion)) {
                        setFuncionUpdateEjecutada(true);
                        getFilasProcesadas().put(rowKey.getRowId(), rowKey);
                        posEditRow(rowKey, funcion); /* fire afterEditRow event? */
                        setFilaEscogida(rowKey);
                        edited = true;
                    }
                }
                if (edited) {
                    mensajeAdvertenciaFinal = null;
                } else {
                    mensajeErrorFinal = CBM.CHECK_CHANGES_EXCEPTION_0;
                }
            }
            return edited;
        } catch (SQLException ex) {
            TLC.getBitacora().fatal(ex);
            throw new ExcepcionAplicacion(ex);
        }
    }

    protected boolean esPermitidoEditar(RowKey rowKey) {
        Bitacora.trace(getClass(), "esPermitidoEditar", rowKey);
        Object object = execute(getBeforeEditingProcedure(), getIdentificacionRecurso(rowKey));
        return object instanceof Exception ? false : object == null || BitUtils.valueOf(object);
    }

    protected boolean esFilaModificable(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaModificable", rowKey, funcion);
        return isRowAvailable(rowKey) && esFilaRecursoActivo(rowKey, funcion)
                && esFilaRecursoAutorizado(rowKey, funcion);
    }

    protected void posEditRow(RowKey rowKey, long funcion) {
        /* fire afterEditRow event? */
        Bitacora.trace(getClass(), "posEditRow", rowKey, funcion);
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a undoRow">
    public boolean undoRow(Set rowSet) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "undoRow");
        if (rowSet.isEmpty()) {
            TLC.getBitacora().warn(CBM.UNDO_CHANGES_NONE);
            return false;
        } else {
            Iterator iterator = rowSet.iterator();
            while (iterator.hasNext()) {
                RowKey rowKey = (RowKey) iterator.next();
                undoRow(rowKey); /* throws ExcepcionAplicacion */
            }
            return true;
        }
    }

    public boolean undoRow(RowKey rowKey) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "undoRow", rowKey);
        try {
            if (isRowAvailable(rowKey)) {
                if (getFilasProcesadas()
                        .containsKey(rowKey.getRowId())) { /* fila insertada o editada y aun no confirmada */
                    setCursorRow(rowKey); /* throws SQLException */
                    if (getCachedRowSet().rowInserted()) { /* throws SQLException */
                        // getCachedRowSet().undoInsert(); throws SQLException Y NO FUNCIONA!
                        super.removeRow(
                                rowKey); /* siempre es posible eliminar lo recion insertado y aun no guardado */
                    } else {
                        // getCachedRowSet().undoUpdate(); /* throws SQLException */ NO FUNCIONA!
                        getCachedRowSet().cancelRowUpdates(); /* throws SQLException */
                    }
                    if (esFilaEscogida(rowKey)) {
                        resetFilaEscogida();
                    }
                    getFilasProcesadas().remove(rowKey.getRowId());
                    getFilasConflictivas().remove(rowKey.getRowId());
                    checkRevertChanges();
                    return true;
                }
            } else {
                TLC.getBitacora().warn(CBM.UNDO_CHANGES_NONE);
            }
            return false;
        } catch (SQLException | DataProviderException ex) {
            TLC.getBitacora().fatal(ex);
            throw new ExcepcionAplicacion(ex);
        }
    }

    private boolean checkRevertChanges() throws DataProviderException {
        //      ejecuta el metodo revertChanges si NO quedan filas agregadas, editadas o eliminadas
        //      vale mas un "por si acaso" ...
        boolean check = (getFilasProcesadas().isEmpty() && getFilasEliminadas() == 0);
        if (check) {
            revertChanges();
            refresh();
        }
        return check;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a removeRow">
    /**
     * {@inheritDoc}
     */
    @Override
    public void removeRow(RowKey rowKey) throws DataProviderException {
        removeRow(rowKey, getFuncionDelete()); /* throws ExcepcionAplicacion */
    }

    public void removeRow(Set rowSet) throws DataProviderException {
        removeRow(rowSet, getFuncionDelete()); /* throws ExcepcionAplicacion */
    }

    public void removeRow(Set rowSet, long funcion) throws DataProviderException {
        Bitacora.trace(getClass(), "removeRow", funcion);
        try {
            setFuncionDelete(funcion); /* throws ExcepcionAplicacion */
            if (rowSet.isEmpty()) {
                TLC.getBitacora().warn(CBM.DELETE_NONE);
            } else {
                resetMensajesFinales();
                mensajeAdvertenciaFinal = CBM.DELETE_NONE;
                Iterator iterator = rowSet.iterator();
                while (iterator.hasNext()) {
                    RowKey rowKey = (RowKey) iterator.next();
                    removeRow(rowKey, funcion); /* throws DataProviderException */
                }
                darMensajeFinal();
            }
        } catch (ExcepcionAplicacion ex) {
            throw new DataProviderException(ex);
        } catch (DataProviderException ex) {
            // viene de removeRow(rowKey, funcion) y por lo tanto ya esta anotado en la bitacora
            throw ex;
        }
    }

    public void removeRow(RowKey rowKey, long funcion) throws DataProviderException {
        Bitacora.trace(getClass(), "removeRow", rowKey, funcion);
        try {
            boolean removed = false;
            if (isRowAvailable(rowKey)) {
                setCursorRow(rowKey); /* throws TableCursorVetoException */
                if (getCachedRowSet().rowInserted()) { /* throws SQLException */
                    undoRow(rowKey); /* siempre es posible eliminar lo recion insertado y aun no guardado */
                } else {
                    if (isFuncionInsertEjecutada() || isFuncionUpdateEjecutada()) {
                        throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.DELETE_ROW_EXCEPTION_4));
                    }
                    setFuncionDelete(funcion); /* throws ExcepcionAplicacion */
                    if (esPermitidoEliminar(rowKey)) {
                        if (esFilaEliminable(rowKey, funcion)) {
                            preRemoveRow(rowKey, funcion); /* fire beforeRemoveRow event? */
                            super.removeRow(rowKey); /* throws DataProviderException */
                            setFuncionDeleteEjecutada(true);
                            getFilasRemovidas().put(rowKey.getRowId(), rowKey);
                            if (esFilaEscogida(rowKey)) {
                                resetFilaEscogida();
                            }
                            getFilasProcesadas().remove(rowKey.getRowId());
                            getFilasConflictivas().remove(rowKey.getRowId());
                            posRemoveRow(rowKey, funcion); /* fire afterRemoveRow event? */
                            incrementaFilasEliminadas();
                            if (cursorNext() || cursorPrevious() || cursorFirst()) {
                                setFilaEscogida();
                            }
                            removed = true;
                        }
                    }
                    if (removed) {
                        mensajeAdvertenciaFinal = null;
                        mensajeInformativoFinal = getMensajeCambiosPorConfirmar();
                    } else {
                        mensajeErrorFinal = CBM.CHECK_CHANGES_EXCEPTION_0;
                    }
                }
            }
        } catch (ExcepcionAplicacion ex) {
            throw new DataProviderException(ex);
        } catch (SQLException ex) {
            TLC.getBitacora().fatal(ex);
            throw new DataProviderException(ex);
        } catch (DataProviderException ex) {
            TLC.getBitacora().fatal(ex);
            throw ex;
        }
    }

    protected boolean esPermitidoEliminar(RowKey rowKey) {
        Bitacora.trace(getClass(), "esPermitidoEliminar", rowKey);
        Object object = execute(getBeforeRemovingProcedure(), getIdentificacionRecurso(rowKey));
        return object instanceof Exception ? false : object == null || BitUtils.valueOf(object);
    }

    protected boolean esFilaEliminable(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaEliminable", rowKey, funcion);
        return isRowAvailable(rowKey) && esFilaRecursoAutorizado(rowKey, funcion);
    }

    protected void preRemoveRow(RowKey rowKey, long funcion) {
        /* fire beforeRemoveRow event? */
        Bitacora.trace(getClass(), "preRemoveRow", rowKey, funcion);
    }

    protected void posRemoveRow(RowKey rowKey, long funcion) {
        /* fire afterRemoveRow event? */
        Bitacora.trace(getClass(), "posRemoveRow", rowKey, funcion);
        FieldKey[] fields = getFieldKeys();
        for (int i = 0; i < fields.length; i++) {
            Object obj = getValue(fields[i]);
            String value = "NULL";
            if (obj != null) {
                value = getValue(fields[i]).toString();
            }
            Bitacora.trace(fields[i].getDisplayName() + " = " + value);
        }
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a processRow">
    public boolean processRow(Set rowSet, long funcion) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "processRow", funcion);
        //      if (!TLC.getControlador().esFuncionAutorizada(funcion)) {
        //          throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.PROCESS_ROW_EXCEPTION_1));
        //      }
        setFuncionBusinessProcess(funcion); /* throws ExcepcionAplicacion */
        if (rowSet.isEmpty()) {
            TLC.getBitacora().warn(CBM.PROCESS_NONE);
            return false;
        }
        boolean processed = false;
        resetMensajesFinales();
        mensajeAdvertenciaFinal = CBM.PROCESS_NONE;
        Iterator iterator = rowSet.iterator();
        while (iterator.hasNext()) {
            RowKey rowKey = (RowKey) iterator.next();
            processed |= processRow(rowKey, funcion); /* throws ExcepcionAplicacion */
        }
        darMensajeFinal();
        return processed;
    }

    public boolean processRow(RowKey rowKey, long funcion) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "processRow", rowKey, funcion);
        if (canProcessRow(rowKey, funcion)) {
            runProcessRow(rowKey, funcion); /* fire onProcessRow event? */
            posProcessRow(rowKey, funcion); /* fire afterProcessRow event? */
            return true;
        }
        return false;
    }

    public boolean canProcessRow(RowKey rowKey, long funcion) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "canProcessRow", rowKey, funcion);
        try {
            boolean processed = false;
            if (isRowAvailable(rowKey)) {
                setCursorRow(rowKey); /* throws SQLException */
                if (getCachedRowSet().rowDeleted() || getCachedRowSet().rowUpdated()
                        || getCachedRowSet().rowInserted()) { /* throws SQLException */
                    throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.PROCESS_ROW_EXCEPTION_3));
                }
                if (isLoteConCambios()) { /*(isFuncionInsertEjecutada() || isFuncionUpdateEjecutada() || isFuncionDeleteEjecutada())*/
                    throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.PROCESS_ROW_EXCEPTION_4));
                }
                //              if (!TLC.getControlador().esFuncionAutorizada(funcion)) {
                //                  throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.PROCESS_ROW_EXCEPTION_1));
                //              }
                setFuncionBusinessProcess(funcion); /* throws ExcepcionAplicacion */
                if (esFilaProcesable(rowKey, funcion)) {
                    TLC.getBitacora().hint(CBM.CHECK_CHANGES_1, getEtiquetaRecurso(rowKey));
                    processed = true;
                }
                if (processed) {
                    mensajeAdvertenciaFinal = null;
                } else {
                    mensajeErrorFinal = CBM.CHECK_CHANGES_EXCEPTION_0;
                }
            }
            return processed;
        } catch (SQLException ex) {
            TLC.getBitacora().fatal(ex);
            throw new ExcepcionAplicacion(ex);
        }
    }

    protected boolean esFilaProcesable(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaProcesable", rowKey, funcion);
        return isRowAvailable(rowKey) && esFilaRecursoAutorizado(rowKey, funcion);
    }

    protected void runProcessRow(RowKey rowKey, long funcion) throws ExcepcionAplicacion {
        /* fire onProcessRow event? */
        Bitacora.trace(getClass(), "runProcessRow", rowKey, funcion);
    }

    protected void posProcessRow(RowKey rowKey, long funcion) {
        /* fire afterProcessRow event? */
        Bitacora.trace(getClass(), "posProcessRow", rowKey, funcion);
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a commit y revert">
    /**
     * (@inheritDoc}
     */
    @Override
    public void commitChanges() throws DataProviderException {
        Bitacora.trace(getClass(), "commitChanges");
        try {
            if (isFuncionDeleteEjecutada() || !getFilasProcesadas().isEmpty()) {
                if (isFuncionDeleteEjecutada() || esLoteValido()) { /* throws ExcepcionAplicacion */
                    beforeCommit();
                    preCommitChanges(); /* graba los rastros de auditoria // throws ExcepcionAplicacion */
                    super.commitChanges(); /* confirma los cambios // throws DataProviderException */
                    posCommitChanges(); /* graba las tareas de usuario // throws ExcepcionAplicacion */
                    afterCommit();
                    resetState();
                } else {
                    throw new ExcepcionAplicacion(TLC.getBitacora().error(CBM.COMMIT_CHANGES_EXCEPTION));
                }
            } else {
                TLC.getBitacora().warn(CBM.NO_CHANGES_TO_COMMIT);
                resetState();
            }
        } catch (DataProviderException ex) {
            TLC.getBitacora().fatal(ex);
            afterCommitException();
            throw ex;
        } catch (Exception ex) {
            afterCommitException();
            throw new DataProviderException(ex);
        }
    }

    private void beforeCommit() {
        //      preCommitRow(rowKey, funcion) modifica tipoRastroFuncion y agrega a listaRastroFuncion y listaTareasUsuario
        tipoRastroFuncion = TipoRastroFunEnumeration.EXITO;
        listaRastroFuncion = getRastrosFuncion();
        listaTareasUsuario = new ArrayList<>();
    }

    private void afterCommit() {
        Long maestro = getIdentificacionMaestro();
        String procedure = maestro == null ? null : getAfterCommitProcedure();
        boolean b0 = procedure != null;
        boolean b1 = listaRastroFuncion != null && !listaRastroFuncion.isEmpty()
                && (testing || loggingEnabledForSuccess());
        boolean b2 = listaTareasUsuario != null && !listaTareasUsuario.isEmpty();
        if (b0 || b1 || b2) {
            Connection connection = TLC.getConnection();
            if (connection != null) {
                try {
                    boolean autoCommit = connection.getAutoCommit();
                    if (DB.setAutoCommit(connection, false)) {
                        if (b0 && TLC.getAgenteSql().isStoredProcedure(procedure)) {
                            Object[] args = new Object[] { maestro };
                            TLC.getAgenteSql().executeProcedure(procedure, args);
                        }
                        if (b1) {
                            for (RastroFuncion rastro : listaRastroFuncion.values()) {
                                TLC.getControlador().grabarRastroFuncion(rastro);
                            }
                        }
                        if (b2) {
                            for (SeudoTareaUsuario seudo : listaTareasUsuario) {
                                TLC.getControlador().grabarTareasUsuario(seudo);
                            }
                        }
                        DB.commit(connection);
                        if (autoCommit) {
                            DB.setAutoCommit(connection, true);
                        }
                    }
                } catch (SQLException ex) {
                    TLC.getBitacora().error(ex);
                    DB.rollback(connection);
                }
            }
        }
        listaRastroFuncion.clear();
        listaTareasUsuario.clear();
    }

    private void afterCommitException() {
        boolean b1 = listaRastroFuncion != null && !listaRastroFuncion.isEmpty()
                && (testing || loggingEnabledForFailure());
        if (b1) {
            Connection connection = TLC.getConnection();
            if (connection != null) {
                try {
                    boolean autoCommit = connection.getAutoCommit();
                    if (DB.setAutoCommit(connection, false)) {
                        grabarRastroFilasConflictivas();
                        DB.commit(connection);
                        if (autoCommit) {
                            DB.setAutoCommit(connection, true);
                        }
                    }
                } catch (SQLException ex) {
                    TLC.getBitacora().error(ex);
                    DB.rollback(connection);
                }
            }
        }
    }

    protected String getAfterCommitProcedure() {
        String tablaDestino = getTablaDestino();
        String tablaMaestro = getTablaMaestro();
        if (StringUtils.isBlank(tablaDestino) || StringUtils.isBlank(tablaMaestro)) {
            return null;
        }
        if (isFuncionInsertEjecutada()) {
            return DB.getAfterAppendingProcedure(tablaDestino, tablaMaestro);
        }
        if (isFuncionUpdateEjecutada()) {
            return DB.getAfterEditingProcedure(tablaDestino, tablaMaestro);
        }
        if (isFuncionDeleteEjecutada()) {
            return DB.getAfterRemovingProcedure(tablaDestino, tablaMaestro);
        }
        return null;
    }

    private void grabarRastroFilasConflictivas() {
        Object object;
        String string;
        RastroFuncion rastro;
        Map filasConflictivas = getFilasConflictivas();
        if (filasConflictivas != null && !filasConflictivas.isEmpty()) {
            for (Object key : filasConflictivas.keySet()) {
                if (key instanceof String) {
                    object = filasConflictivas.get(key);
                    if (object instanceof String) {
                        string = (String) object;
                        if (string.substring(0, 1).matches("[123]")) {
                            rastro = listaRastroFuncion.get((String) key);
                            if (rastro != null) {
                                rastro.setNumeroCondicionEjeFun(
                                        CondicionEjeFunEnumeration.EJECUCION_CANCELADA.intValue());
                                rastro.setDescripcionError(string.substring(1));
                                TLC.getControlador().grabarRastroFuncion(rastro);
                            }
                        }
                    }
                }
            }
        }
    }

    private boolean loggingEnabledForSuccess() {
        switch (tipoRastroFuncion) {
        case EXITO:
        case AMBOS:
            return true;
        default:
            return false;
        }
    }

    private boolean loggingEnabledForFailure() {
        switch (tipoRastroFuncion) {
        case ERROR:
        case AMBOS:
            return true;
        default:
            return false;
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void revertChanges() throws DataProviderException {
        Bitacora.trace(getClass(), "revertChanges");
        super.revertChanges(); /* throws DataProviderException */
        resetState();
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a refresh">
    /**
     * {@inheritDoc}
     */
    @Override
    public void refresh() throws DataProviderException {
        Bitacora.trace(getClass(), "refresh");
        super.refresh(); /* throws DataProviderException */
        resetFlags();
        resetState();
        setFuncionSelectEjecutada(true);
        //      setFuncionDeleteEjecutada(false) en este punto, porque despues del refresh ya no ocurre el java.lang.IllegalArgumentException
        setFuncionDeleteEjecutada(
                false); /* removeRow + appendRow + setCursorRow = java.lang.IllegalArgumentException ... */
        restoreFilaEscogida();
        int limite = getLimiteFilasFuncionSelect();
        if (limite > 0) {
            int filas = getRowCount();
            Bitacora.trace(getClass(), "refresh", "limite=" + limite, "filas=" + filas);
            if (filas == limite) {
                TLC.getBitacora().warn(CBM.SELECT_ROW_LIMIT_REACHED, String.valueOf(limite));
            }
        }
    }

    private void resetFlags() {
        //      setFiltroFuncionSelectModificado(false);
        //      setCodigoFuncionSelectModificado(false);
        //      setNombreFuncionSelectModificado(false);
    }

    private void resetState() {
        getFilasElegidas().clear();
        getFilasProcesadas().clear();
        getFilasRemovidas().clear();
        getFilasConflictivas().clear();
        setFilasEliminadas(0);
        getRastrosFuncion().clear();
        setFuncionInsertEjecutada(false);
        setFuncionUpdateEjecutada(false);
        //----->setFuncionDeleteEjecutada(false); /* removeRow + appendRow + setCursorRow = java.lang.IllegalArgumentException ... */
    }

    public void restoreFilaEscogida() {
        Bitacora.trace(getClass(), "restoreFilaEscogida");
        try {
            if (isLoteSinFilas()) {
                resetFilaEscogida();
            } else {
                RowKey rowKey = null;
                if (isRecursoIdentificable()) {
                    String clave = getRecursoIdentificableDataProvider().getColumnaIdentificacionRecurso();
                    Long valor = getIdentificacionFilaEscogida();
                    Bitacora.trace(getClass(), "restoreFilaEscogida", clave + "=" + valor);
                    if (valor != null) {
                        rowKey = findFirst(clave, valor);
                    }
                }
                if (rowKey == null && isRecursoEnumerable()) {
                    String clave = getRecursoEnumerableDataProvider().getColumnaNumeroRecurso();
                    Integer valor = getNumeroFilaEscogida();
                    Bitacora.trace(getClass(), "restoreFilaEscogida", clave + "=" + valor);
                    if (valor != null) {
                        rowKey = findFirst(clave, valor);
                    }
                }
                if (rowKey == null && isRecursoCodificable()) {
                    String clave = getRecursoCodificableDataProvider().getColumnaCodigoRecurso();
                    String valor = getCodigoFilaEscogida();
                    Bitacora.trace(getClass(), "restoreFilaEscogida", clave + "=" + valor);
                    if (valor != null) {
                        rowKey = findFirst(clave,
                                valor); /* TODO: OJO con (appendRow + codigo que ya existe + revert + refresh) */
                    }
                }
                if (isRowAvailable(rowKey)) {
                    setCursorRow(rowKey);
                    setFilaEscogida(rowKey);
                } else {
                    setFilaEscogida(); /* attempt to set to current cursor row */
                }
            }
        } catch (Exception ex) {
            resetFilaEscogida();
        }
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a release, ...">
    public void release() throws SQLException {
        getCachedRowSet().release();
        incrementaVersionComandoSelect();
        reset();
    }

    public void setComandoEmptyCachedRowSet() throws ExcepcionAplicacion {
        setComandoEmptyCachedRowSet("SELECT * FROM " + getCodigoDominioRecurso() + " WHERE (0=1)");
    }

    public void setComandoEmptyCachedRowSet(String comando) throws ExcepcionAplicacion {
        setComandoCachedRowSet(comando, true);
        reset();
    }

    private void reset() {
        resetFilter();
        resetState();
        setFuncionSelectEjecutada(false);
        setFuncionDeleteEjecutada(false);
        setFilaEscogida(null);
    }

    public void storeQuery() {
        storeCommand();
        storeFilter();
        storeMaster();
    }

    public void restoreQuery() throws ExcepcionAplicacion {
        restoreCommand();
        restoreFilter();
        restoreMaster();
    }

    public void resetFilter() {
        if (isFiltroAnulado()) {
            return;
        }
        setFiltroFuncionSelect(null);
        setCodigoFuncionSelect(null);
        setNombreFuncionSelect(null);
        //      setFiltroFuncionSelectModificado(true);
        //      setCodigoFuncionSelectModificado(true);
        //      setNombreFuncionSelectModificado(true);
        for (CampoBusqueda campo : getCamposBusqueda().values()) {
            campo.setValor(null);
        }
        setFiltroAnulado(true);
    }

    private void resetMaster() {
        setColumnaMaestro(null);
        setIdentificacionMaestro(null);
    }

    private void storeCommand() {
        Bitacora.trace(getClass(), "storeCommand", "Comando=" + getComandoSelectAnsi());
        Bitacora.trace(getClass(), "storeCommand", "Version=" + getVersionComandoSelect());
        setComandoSelectAnterior(getComandoSelectAnsi());
        setVersionComandoSelectAnterior(getVersionComandoSelect());
    }

    private void restoreCommand() throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "restoreCommand", "Comando=" + getComandoSelectAnterior());
        Bitacora.trace(getClass(), "restoreCommand", "Version=" + getVersionComandoSelectAnterior());
        setComandoCachedRowSet(getComandoSelectAnterior(), true);
        setVersionComandoSelect(getVersionComandoSelectAnterior());
    }

    private void storeFilter() {
        Bitacora.trace(getClass(), "storeFilter", "Filtro=" + getFiltroFuncionSelect());
        Bitacora.trace(getClass(), "storeFilter", "Codigo=" + getCodigoFuncionSelect());
        Bitacora.trace(getClass(), "storeFilter", "Nombre=" + getNombreFuncionSelect());
        setFiltroAnulado(false);
        setFiltroFuncionSelectAnterior(getFiltroFuncionSelect());
        setCodigoFuncionSelectAnterior(getCodigoFuncionSelect());
        setNombreFuncionSelectAnterior(getNombreFuncionSelect());
        for (CampoBusqueda campo : getCamposBusqueda().values()) {
            campo.setValorAnterior(campo.getValor());
        }
    }

    public void restoreFilter() {
        Bitacora.trace(getClass(), "restoreFilter", "Filtro=" + getFiltroFuncionSelectAnterior());
        Bitacora.trace(getClass(), "restoreFilter", "Codigo=" + getCodigoFuncionSelectAnterior());
        Bitacora.trace(getClass(), "restoreFilter", "Nombre=" + getNombreFuncionSelectAnterior());
        setFiltroAnulado(false);
        setFiltroFuncionSelect(getFiltroFuncionSelectAnterior());
        setCodigoFuncionSelect(getCodigoFuncionSelectAnterior());
        setNombreFuncionSelect(getNombreFuncionSelectAnterior());
        //      setFiltroFuncionSelectModificado(false);
        //      setCodigoFuncionSelectModificado(false);
        //      setNombreFuncionSelectModificado(false);
        for (CampoBusqueda campo : getCamposBusqueda().values()) {
            campo.setValor(campo.getValorAnterior());
        }
    }

    private void storeMaster() {
        Bitacora.trace(getClass(), "storeMaster", "Clave=" + getColumnaMaestro());
        Bitacora.trace(getClass(), "storeMaster", "Valor=" + getIdentificacionMaestro());
        setColumnaMaestroAnterior(getColumnaMaestro());
        setIdentificacionMaestroAnterior(getIdentificacionMaestro());
    }

    private void restoreMaster() {
        Bitacora.trace(getClass(), "restoreMaster", "Clave=" + getColumnaMaestroAnterior());
        Bitacora.trace(getClass(), "restoreMaster", "valor=" + getIdentificacionMaestroAnterior());
        setColumnaMaestro(getColumnaMaestroAnterior());
        setIdentificacionMaestro(getIdentificacionMaestroAnterior());
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a validaciones">
    public boolean esFilaAmaestrable(RowKey rowKey, String referencia) {
        if (isNotRowAvailable(rowKey)) {
            return false;
        }
        if (StringUtils.isBlank(referencia)) {
            return false;
        }
        return true;
    }

    public boolean esFilaAutorizada(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaAutorizada", rowKey, funcion);
        boolean es = true;
        try {
            if (isRowAvailable(rowKey)) {
                setCursorRow(rowKey); /* throws SQLException */
                if (getCachedRowSet().rowDeleted() || getCachedRowSet().rowUpdated()
                        || getCachedRowSet().rowInserted()) { /* throws SQLException */
                    TLC.getBitacora().error(CBM.PROCESS_ROW_EXCEPTION_3);
                    es = false;
                }
                if (isLoteConCambios()) { /*(isFuncionInsertEjecutada() || isFuncionUpdateEjecutada() || isFuncionDeleteEjecutada())*/
                    TLC.getBitacora().error(CBM.PROCESS_ROW_EXCEPTION_4);
                    es = false;
                }
                if (TLC.getControlador().esFuncionAutorizada(funcion)) {
                    es &= esFilaRecursoAutorizado(rowKey, funcion);
                } else {
                    TLC.getBitacora().error(CBM.PROCESS_ROW_EXCEPTION_1);
                    es = false;
                }
            } else {
                TLC.getBitacora().warn(CBM.PROCESS_NONE);
                es = false;
            }
        } catch (SQLException ex) {
            TLC.getBitacora().fatal(ex);
            es = false;
        }
        return es;
    }

    public boolean esFilaRecursoActivo(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaRecursoActivo", rowKey, funcion);
        if (isNotRowAvailable(rowKey)) {
            return false;
        }
        if (isRecursoDesactivable()) {
            Boolean inactivo = getRecursoDesactivableDataProvider().getEsRecursoInactivo(rowKey);
            if (BitUtils.valueOf(inactivo)) {
                TLC.getBitacora().error(CBM.RECURSO_INACTIVO, getEtiquetaRecurso(rowKey));
                return false;
            }
        }
        return true;
    }

    public boolean esFilaRecursoAutorizado(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaRecursoAutorizado", rowKey, funcion);
        return esFilaRecursoPropio(rowKey, funcion)
                && (segmentoIgualPropietario() || esFilaSegmentoAutorizado(rowKey, funcion));
    }

    private boolean segmentoIgualPropietario() {
        if (isRecursoPersonalizable() && isRecursoSegmentable()) {
            String cpr = getRecursoPersonalizableDataProvider().getColumnaPropietarioRecurso();
            String csr = getRecursoSegmentableDataProvider().getColumnaSegmentoRecurso();
            return cpr.equals(csr);
        }
        return false;
    }

    public boolean esFilaRecursoPropio(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaRecursoPropio", rowKey, funcion);
        if (isNotRowAvailable(rowKey)) {
            return false;
        }
        if (isRecursoPersonalizable()) {
            Long propietario = getRecursoPersonalizableDataProvider().getPropietarioRecurso(rowKey);
            if (TLC.getControlador().esPropietarioRecurso(propietario, funcion)) {
                return true;
            }
            TLC.getBitacora().error(CBM.USUARIO_NO_PROPIETARIO, getEtiquetaRecurso(rowKey));
            return false;
        }
        return true;
    }

    public boolean esFilaSegmentoAutorizado(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaSegmentoAutorizado", rowKey, funcion);
        if (isNotRowAvailable(rowKey)) {
            return false;
        }
        if (isRecursoSegmentable()) {
            Long segmento = getRecursoSegmentableDataProvider().getSegmentoRecurso(rowKey);
            if (TLC.getControlador().esSegmentoAutorizado(segmento, funcion)) {
                return true;
            }
            TLC.getBitacora().error(CBM.SEGMENTO_NO_AUTORIZADO, getEtiquetaRecurso(rowKey));
            return false;
        }
        return true;
    }

    public boolean esLoteValido() throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "esLoteValido");
        getFilasConflictivas().clear();
        filasProcesadasPorConfirmar = 0;
        boolean ok = true;
        Collection filas = getFilasProcesadas().values();
        if (filas.isEmpty()) {
            // la lista de filas procesadas no incluye las filas eliminadas,
            // por lo tanto seria valido hacer commit aun cuando este vacia
            // ok = isFuncionDeleteEjecutada();
            // if (!ok)
            // TLC.getBitacora().warn(CBM.NO_CHANGES_TO_COMMIT);
        } else {
            Iterator iterator = filas.iterator();
            while (iterator.hasNext()) {
                RowKey rowKey = (RowKey) iterator.next();
                ok &= esFilaValida(rowKey, true);
            }
        }
        return ok;
    }

    public boolean esFilaValida(RowKey rowKey) throws ExcepcionAplicacion {
        return esFilaValida(rowKey, true);
    }

    private boolean esFilaValida(RowKey rowKey, boolean cursor) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "esFilaValida", rowKey, String.valueOf(cursor));
        if (isNotRowAvailable(rowKey)) {
            return false;
        }
        try {
            long funcion = -1L;
            int status = SyncResolver.NO_ROW_CONFLICT;
            int tipoError = 3; /* OJO con la constante, 3 -> fila con uno o mas errores, todos conocidos */
            boolean ejecutada = false;
            boolean autorizada = false;
            String comando;
            String mensaje;
            if (cursor) {
                setCursorRow(rowKey); /* throws TableCursorVetoException */
            }
            if (getCachedRowSet().rowInserted()) { /* throws SQLException */
                funcion = getFuncionInsert();
                status = SyncResolver.INSERT_ROW_CONFLICT;
                ejecutada = true; /* isFuncionInsertEjecutada(); */
                autorizada = isFuncionInsertAutorizada();
            } else {
                if (getCachedRowSet().rowUpdated()) { /* throws SQLException */
                    funcion = getFuncionUpdate();
                    status = SyncResolver.UPDATE_ROW_CONFLICT;
                    ejecutada = true; /* isFuncionUpdateEjecutada(); */
                    autorizada = isFuncionUpdateAutorizada();
                }
            }
            boolean es = true;
            if (ejecutada) {
                filasProcesadasPorConfirmar++;
                if (autorizada) {
                    es = esFilaValida(rowKey, funcion); /* check */
                    if (es) {
                        Bitacora.trace(CBM.CHECK_CHANGES_1, getEtiquetaRecurso(rowKey));
                    } else {
                        comando = DBUtils.getTransactionLabel(status);
                        mensaje = tipoError + TLC.getBitacora().error(CBM.CHECK_CHANGES_EXCEPTION_2, comando,
                                getEtiquetaRecurso(rowKey));
                        getFilasConflictivas().put(rowKey.getRowId(), mensaje);
                    }
                } else {
                    comando = DBUtils.getTransactionLabel(status);
                    mensaje = tipoError + TLC.getBitacora().error(CBM.CHECK_CHANGES_EXCEPTION_2, comando,
                            getEtiquetaRecurso(rowKey));
                    getFilasConflictivas().put(rowKey.getRowId(), mensaje);
                }
            } else {
                Bitacora.trace(CBM.CHECK_CHANGES_2, getEtiquetaRecurso(rowKey));
            }
            return es;
        } catch (IllegalArgumentException | SQLException | DataProviderException ex) {
            TLC.getBitacora().fatal(ex);
            throw new ExcepcionAplicacion(ex);
        }
    }

    protected boolean esFilaValida(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "esFilaValida", rowKey, funcion);
        return rowChecker == null ? isRowAvailable(rowKey) : rowChecker.isValidRow(rowKey);
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a preCommitRow">
    protected void preCommitChanges() throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "preCommitChanges");
        if (getFilasProcesadas().size() > 0) {
            Collection filas = getFilasProcesadas().values();
            Iterator iterator = filas.iterator();
            while (iterator.hasNext()) {
                RowKey rowKey = (RowKey) iterator.next();
                preCommitRow(rowKey, true);
            }
        }
        if (getFilasRemovidas().size() > 0) {
            Collection filas = getFilasRemovidas().values();
            Iterator iterator = filas.iterator();
            while (iterator.hasNext()) {
                RowKey rowKey = (RowKey) iterator.next();
                preCommitRow(rowKey, false);
            }
        }
    }

    protected void preCommitRow(RowKey rowKey) throws ExcepcionAplicacion {
        preCommitRow(rowKey, true);
    }

    protected void preCommitRow(RowKey rowKey, boolean cursor) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "preCommitRow", rowKey, String.valueOf(cursor));
        try {
            long funcion = -1L;
            boolean ejecutada = false;
            if (cursor) {
                setCursorRow(rowKey); /* throws TableCursorVetoException */
                if (getCachedRowSet().rowInserted()) { /* throws SQLException */
                    funcion = getFuncionInsert();
                    ejecutada = true; /* isFuncionInsertEjecutada(); */
                    if (isRecursoIdentificable()) {
                        Long identificacion = getRecursoIdentificableDataProvider()
                                .getIdentificacionRecurso(rowKey);
                        if (identificacion == null || identificacion == 0) {
                            identificacion = LongUtils.getNewId();
                            getRecursoIdentificableDataProvider().setIdentificacionRecurso(rowKey, identificacion);
                        }
                        if (isRecursoCodificable()) {
                            String codigo = getRecursoCodificableDataProvider().getCodigoRecurso(rowKey);
                            if (StringUtils.isBlank(codigo)) {
                                codigo = identificacion.toString();
                                getRecursoCodificableDataProvider().setCodigoRecurso(rowKey, codigo);
                            }
                        }
                    }
                    if (isRecursoEnumerable() && isRecursoCodificable()) {
                        String codigo = getRecursoCodificableDataProvider().getCodigoRecurso(rowKey);
                        if (StringUtils.isBlank(codigo)) {
                            Integer numero = getRecursoEnumerableDataProvider().getNumeroRecurso(rowKey);
                            if (numero != null) {
                                codigo = numero.toString();
                                getRecursoCodificableDataProvider().setCodigoRecurso(rowKey, codigo);
                            }
                        }
                    }
                } else {
                    if (getCachedRowSet().rowUpdated()) { /* throws SQLException */
                        funcion = getFuncionUpdate();
                        ejecutada = true; /* isFuncionUpdateEjecutada(); */
                    } else {
                        if (getCachedRowSet().rowDeleted()) { /* throws SQLException */
                            funcion = getFuncionDelete();
                            ejecutada = true; /* isFuncionDeleteEjecutada(); */
                        }
                    }
                }
            } else {
                funcion = getFuncionDelete();
                ejecutada = true; /* isFuncionDeleteEjecutada(); */
            }
            if (ejecutada && funcion > 0) {
                preCommitRow(rowKey, funcion);
            } else {
                Bitacora.trace(CBM.CHECK_CHANGES_2, getEtiquetaRecurso(rowKey));
            }
        } catch (IllegalArgumentException | SQLException | DataProviderException ex) {
            TLC.getBitacora().fatal(ex);
            throw new ExcepcionAplicacion(ex);
        }
    }

    protected void preCommitRow(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "preCommitRow", rowKey, funcion);
        //      FieldKey[] fields = getFieldKeys();
        //      for (int i = 0; i < fields.length; i++) {
        //          Object obj = getValue(fields[i]);
        //          String value = "NULL";
        //          if (obj != null) {
        //              value = getValue(fields[i]).toString();
        //          }
        //          Bitacora.trace(fields[i].getDisplayName() + " = " + value);
        //      }
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a posCommitRow">
    protected void posCommitChanges() throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "posCommitChanges");
        if (getFilasProcesadas().size() > 0) {
            Collection filas = getFilasProcesadas().values();
            Iterator iterator = filas.iterator();
            while (iterator.hasNext()) {
                RowKey rowKey = (RowKey) iterator.next();
                posCommitRow(rowKey, true);
            }
        }
    }

    protected void posCommitRow(RowKey rowKey) throws ExcepcionAplicacion {
        posCommitRow(rowKey, true);
    }

    protected void posCommitRow(RowKey rowKey, boolean cursor) throws ExcepcionAplicacion {
        Bitacora.trace(getClass(), "posCommitRow", rowKey, String.valueOf(cursor));
        try {
            long funcion = -1L;
            boolean ejecutada = false;
            if (cursor) {
                setCursorRow(rowKey); /* throws TableCursorVetoException */
                if (isFuncionInsertEjecutada()) {
                    funcion = getFuncionInsert();
                    ejecutada = true; /* isFuncionInsertEjecutada(); */
                } else if (isFuncionUpdateEjecutada()) {
                    funcion = getFuncionUpdate();
                    ejecutada = true; /* isFuncionUpdateEjecutada(); */
                }
            }
            if (ejecutada && funcion > 0) {
                posCommitRow(rowKey, funcion);
            }
        } catch (IllegalArgumentException | DataProviderException ex) {
            TLC.getBitacora().fatal(ex);
            throw new ExcepcionAplicacion(ex);
        }
    }

    protected void posCommitRow(RowKey rowKey, long funcion) {
        Bitacora.trace(getClass(), "posCommitRow", rowKey, funcion);
        //      FieldKey[] fields = getFieldKeys();
        //      for (int i = 0; i < fields.length; i++) {
        //          Object obj = getValue(fields[i]);
        //          String value = "NULL";
        //          if (obj != null) {
        //              value = getValue(fields[i]).toString();
        //          }
        //          Bitacora.trace(fields[i].getDisplayName() + " = " + value);
        //      }
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a setValue">
    //  /**
    //   * {@inheritDoc}
    //   */
    //    @Override
    //    public void setValue(String fieldId, Object value) throws DataProviderException {
    //        Object object = getSqlObject(fieldId, value);
    //        super.setValue(fieldId, object);
    //    }
    //
    //  /**
    //   * {@inheritDoc}
    //   */
    //    @Override
    //    public void setValue(String fieldId, RowKey row, Object value) throws DataProviderException {
    //        Object object = getSqlObject(fieldId, value);
    //        super.setValue(fieldId, row, object);
    //    }
    //
    //  /**
    //   * {@inheritDoc}
    //   */
    //  @Override
    //  public void setValue(FieldKey fieldKey, Object value) throws DataProviderException {
    //      Object object = getSqlObject(fieldKey, value);
    //      super.setValue(fieldKey, object);
    //  }
    //
    /**
     * {@inheritDoc}
     */
    @Override
    public void setValue(FieldKey fieldKey, RowKey row, Object value) throws DataProviderException {
        Bitacora.trace(getClass(), "setValue", fieldKey, row, value);
        Object object = getSqlObject(fieldKey, value);
        String columna = fieldKey.getDisplayName();
        if ((isFuncionInsertEjecutada() && isColumnaInsertable(columna))
                || (isFuncionUpdateEjecutada() && isColumnaModificable(columna))) {
            super.setValue(fieldKey, row, object);
        } else {
            Bitacora.trace("IllegalStateException @ "
                    + Bitacora.getTextoMetodo(getClass(), "setValue", fieldKey, row, value));
        }
    }

    private static Calendar calendar = Calendar.getInstance();

    private Object getSqlObject(FieldKey fieldKey, Object value) {
        if (value == null) {
            return null;
        }
        String fieldId = fieldKey.getFieldId();
        int type = getSqlColumnType(fieldId);
        boolean nullable = isNullableColumn(fieldId);
        if (nullable && value instanceof String && StringUtils.isBlank((String) value)) {
            return null;
        }
        Object object = value;
        Bitacora.trace(fieldId + " (" + type + ", " + nullable + ") = (" + object.getClass().getSimpleName() + ") "
                + object);
        switch (type) {
        case java.sql.Types.BIT:
        case java.sql.Types.BOOLEAN:
            object = BitUtils.toBoolean(value);
            break;
        case java.sql.Types.TINYINT:
            object = NumUtils.toByte(value);
            break;
        case java.sql.Types.SMALLINT:
            object = NumUtils.toShort(value);
            break;
        case java.sql.Types.INTEGER:
            object = NumUtils.toInteger(value);
            break;
        case java.sql.Types.BIGINT:
            object = NumUtils.toLong(value);
            break;
        case java.sql.Types.REAL:
            object = NumUtils.toFloat(value);
            break;
        case java.sql.Types.DOUBLE:
        case java.sql.Types.FLOAT:
            object = NumUtils.toDouble(value);
            break;
        case java.sql.Types.DECIMAL:
        case java.sql.Types.NUMERIC:
            object = NumUtils.toBigDecimal(value);
            break;
        case java.sql.Types.DATE:
            object = TimeUtils.toDate(value);
            break;
        case java.sql.Types.TIME:
            object = TimeUtils.toTime(value);
            break;
        case java.sql.Types.TIMESTAMP:
            object = TimeUtils.toTimestamp(value);
            break;
        default:
            break;
        }
        Bitacora.trace(fieldId + " (" + type + ", " + nullable + ") = (" + object.getClass().getSimpleName() + ") "
                + object);
        return object;
    }

    private int getSqlColumnType(String fieldId) {
        try {
            ResultSetMetaData rsmd = getCachedRowSet().getMetaData();
            int numberOfColumns = rsmd.getColumnCount();
            for (int i = 1; i <= numberOfColumns; i++) {
                if (rsmd.getColumnName(i).equalsIgnoreCase(fieldId)) {
                    return rsmd.getColumnType(i);
                }
            }
        } catch (Exception ex) {
            TLC.getBitacora().fatal(ex);
        }
        return java.sql.Types.OTHER;
    }

    private boolean isNullableColumn(String fieldId) {
        try {
            ResultSetMetaData rsmd = getCachedRowSet().getMetaData();
            int numberOfColumns = rsmd.getColumnCount();
            for (int i = 1; i <= numberOfColumns; i++) {
                if (rsmd.getColumnName(i).equalsIgnoreCase(fieldId)) {
                    if (rsmd.isNullable(i) == ResultSetMetaData.columnNullable) {
                        return true;
                    } else {
                        return false;
                    }
                }
            }
        } catch (Exception ex) {
            TLC.getBitacora().fatal(ex);
        }
        return false;
    }

    public boolean isColumnaDisponible(String fieldId) {
        try {
            ResultSetMetaData rsmd = getCachedRowSet().getMetaData();
            int numberOfColumns = rsmd.getColumnCount();
            for (int i = 1; i <= numberOfColumns; i++) {
                if (rsmd.getColumnName(i).equalsIgnoreCase(fieldId)) {
                    return true;
                }
            }
        } catch (Exception ex) {
            TLC.getBitacora().fatal(ex);
        }
        return false;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos correspondientes a funciones get">
    public String getFuncionGetIndicadorInactivo() {
        return null;
    }

    public String getParametroFuncionGetIndicadorInactivo() {
        return null;
    }

    public String getFuncionGetPropietario() {
        return null;
    }

    public String getParametroFuncionGetPropietario() {
        return null;
    }

    public String getFuncionGetSegmento() {
        return null;
    }

    public String getParametroFuncionGetSegmento() {
        return null;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos set maestro, indicador inactivo, propietario y segmento">
    public void setMaestro(RowKey rowKey) {
        String columna = getColumnaMaestro();
        if (isRowAvailable(rowKey) && StringUtils.isNotBlank(columna)) {
            //          Bitacora.trace(getClass(), "setMaestro", columna, rowKey);
            Object maestro = getValue(columna, rowKey);
            if (maestro == null) {
                maestro = getIdentificacionMaestro();
                if (maestro != null) {
                    Bitacora.trace(getClass(), "setMaestro", columna, rowKey, maestro);
                    setValue(columna, rowKey, maestro);
                }
            }
        }
    }

    public void setIndicadorInactivo(RowKey rowKey) {
        if (isRowAvailable(rowKey) && isRecursoDesactivable()) {
            //          Bitacora.trace(getClass(), "setIndicadorInactivo", rowKey);
            Boolean indicador = getRecursoDesactivableDataProvider().getEsRecursoInactivo(rowKey);
            if (indicador == null) {
                indicador = false;
                Bitacora.trace(getClass(), "setIndicadorInactivo", rowKey, indicador);
                getRecursoDesactivableDataProvider().setEsRecursoInactivo(rowKey, indicador);
            }
            // <editor-fold defaultstate="collapsed">
            //          String funcion = getFuncionGetIndicadorInactivo();
            //          String parametro = getParametroFuncionGetIndicadorInactivo();
            //          if (StringUtils.isNotBlank(funcion) && StringUtils.isNotBlank(parametro)) {
            //              Object argumento = getValue(parametro, rowKey);
            //              if (argumento != null) {
            //                  Object objeto = execute(funcion, argumento);
            //                  indicador = BitUtils.toBoolean(objeto);
            //                  Bitacora.trace(getClass(), "setIndicadorInactivo", rowKey, indicador);
            //                  getRecursoDesactivableDataProvider().setEsRecursoInactivo(rowKey, indicador);
            //              }
            //          }
            // </editor-fold>
        }
    }

    public void setPropietario(RowKey rowKey) {
        if (isRowAvailable(rowKey) && isRecursoPersonalizable()) {
            //          Bitacora.trace(getClass(), "setPropietario", rowKey);
            Long propietario = getRecursoPersonalizableDataProvider().getPropietarioRecurso(rowKey);
            if (propietario == null) {
                propietario = TLC.getUsuarioActual().getIdUsuario();
                Bitacora.trace(getClass(), "setPropietario", rowKey, propietario);
                getRecursoPersonalizableDataProvider().setPropietarioRecurso(rowKey, propietario);
            }
            // <editor-fold defaultstate="collapsed">
            //          String funcion = getFuncionGetPropietario();
            //          String parametro = getParametroFuncionGetPropietario();
            //          if (StringUtils.isNotBlank(funcion) && StringUtils.isNotBlank(parametro)) {
            //              Object argumento = getValue(parametro, rowKey);
            //              if (argumento != null) {
            //                  Object objeto = execute(funcion, argumento);
            //                  propietario = NumUtils.toLong(objeto);
            //                  Bitacora.trace(getClass(), "setPropietario", rowKey, propietario);
            //                  getRecursoPersonalizableDataProvider().setPropietarioRecurso(rowKey, propietario);
            //              }
            //          }
            // </editor-fold>
        }
    }
    //
    // <editor-fold defaultstate="collapsed">
    //  public void setSegmento(RowKey rowKey) {
    //      if (isRowAvailable(rowKey) && isRecursoSegmentable()) {
    //          Bitacora.trace(getClass(), "setSegmento", rowKey);
    //          String funcion = getFuncionGetSegmento();
    //          String parametro = getParametroFuncionGetSegmento();
    //          if (StringUtils.isNotBlank(funcion) && StringUtils.isNotBlank(parametro)) {
    //              String maestro = "{master}";
    //              if (funcion.contains(maestro) || parametro.contains(maestro)) {
    //                  String tabla = getTablaMaestro();
    //                  if (StringUtils.isBlank(tabla)) {
    //                      return;
    //                  }
    //                  funcion = funcion.replace(maestro, tabla);
    //                  parametro = getColumnaMaestro();
    //                  if (StringUtils.isBlank(parametro)) {
    //                      return;
    //                  }
    //              }
    //              Object argumento = getValue(parametro, rowKey);
    //              if (argumento != null) {
    //                  Object objeto = execute(funcion, argumento);
    //                  Long segmento = NumUtils.toLong(objeto);
    //                  Bitacora.trace(getClass(), "setSegmento", rowKey, segmento);
    //                  getRecursoSegmentableDataProvider().setSegmentoRecurso(rowKey, segmento);
    //              }
    //          }
    //      }
    //  }
    // </editor-fold>
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="metodos execute y get procedure">
    protected Object execute(String procedure, Object argumento) { // throws SQLException
        Bitacora.trace(getClass(), "execute", procedure, argumento);
        if (StringUtils.isNotBlank(procedure) && argumento != null) {
            try {
                if (TLC.getAgenteSql().isStoredProcedure(procedure)) {
                    Object[] args = new Object[] { argumento };
                    Object resultado = TLC.getAgenteSql().executeProcedure(procedure, args);
                    if (resultado instanceof ResultSet) {
                        ResultSet resultSet = (ResultSet) resultado;
                        if (resultSet.next()) {
                            return resultSet.getObject(1);
                        }
                        //                  } else if (resultado instanceof Number) {
                        //                      return resultado;
                    }
                    return resultado;
                }
            } catch (SQLException ex) {
                String localizedMessage = DBUtils.getProperErrorMessage(ex.getLocalizedMessage());
                TLC.getBitacora().error(localizedMessage);
                return ex;
            }
        }
        return null;
    }

    protected String getBeforeAppendingProcedure() {
        String tablaDestino = getTablaDestino();
        String tablaMaestro = getTablaMaestro();
        return DB.getBeforeAppendingProcedure(tablaDestino, tablaMaestro);
    }

    protected String getBeforeEditingProcedure() {
        String tablaDestino = getTablaDestino();
        return DB.getBeforeEditingProcedure(tablaDestino);
    }

    protected String getBeforeRemovingProcedure() {
        String tablaDestino = getTablaDestino();
        return DB.getBeforeRemovingProcedure(tablaDestino);
    }

    protected String getBeforeAppendingProcedureDefaultErrorMessage() {
        return null;
    }

    protected String getBeforeEditingProcedureDefaultErrorMessage() {
        return null;
    }

    protected String getBeforeRemovingProcedureDefaultErrorMessage() {
        return null;
    }
    // </editor-fold>

}