AsistenteTiposIVA.cs

using sage.ew.db;
using sage.ew.contabilidad;
using sage.ew.formul.Classes;
using sage.ew.functions;
using sage.ew.global;
using sage.ew.objetos;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace sage.ew.articulo.Clases
{
    public class DatosIva
    {
        public string _IvaRep = Convert.ToString(EW_GLOBAL._GetVariable("wc_IvaRep", "477"));
        public string _IvaSop = Convert.ToString(EW_GLOBAL._GetVariable("wc_IvaSop", "472"));
        public string _IvaRecSop = Convert.ToString(EW_GLOBAL._GetVariable("wc_recsop", "472"));
        public string _IvaRecRep = Convert.ToString(EW_GLOBAL._GetVariable("wc_recrep", "477"));
        public string _IvaPendSop = Convert.ToString(EW_GLOBAL._GetVariable("wc_pendedsop", ""));
        public string _IvaPendRep = Convert.ToString(EW_GLOBAL._GetVariable("wc_pendevrep", ""));
        public string _IvaRecPendSop = Convert.ToString(EW_GLOBAL._GetVariable("wc_recsopcdev", ""));
        public string _IvaRecPendRep = Convert.ToString(EW_GLOBAL._GetVariable("wc_recrepcdev", ""));
        public string _IvaProrrataSop = Convert.ToString(EW_GLOBAL._GetVariable("wc_prtivsopnd", ""));
        public string _IvaProrrataPendSop = Convert.ToString(EW_GLOBAL._GetVariable("wc_prtivsndpd", ""));

        public string _IvaRep3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_IvaRep", "477")).Substring(0, 3);
        public string _IvaSop3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_IvaSop", "472")).Substring(0, 3);
        public string _IvaRecSop3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_recsop", "472")).Substring(0, 3);
        public string _IvaRecRep3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_recrep", "477")).Substring(0, 3);
        public string _IvaPendSop3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_pendedsop", "")).Substring(0, 3);
        public string _IvaPendRep3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_pendevrep", "")).Substring(0, 3);
        public string _IvaRecPendSop3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_recsopcdev", "")).Substring(0, 3);
        public string _IvaRecPendRep3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_recrepcdev", "")).Substring(0, 3);
        public string _IvaProrrataSop3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_prtivsopnd", "")).Substring(0, 3);
        public string _IvaProrrataPendSop3 = Convert.ToString(EW_GLOBAL._GetVariable("wc_prtivsndpd", "")).Substring(0, 3);

        public static Int32 _LenCodigo = DB.SQLAnchuraCampo("GESTION", "TIPO_IVA", "CODIGO");

        public static Int32 _LenNombre = DB.SQLAnchuraCampo("GESTION", "TIPO_IVA", "NOMBRE");

        public enum TipoImpuesto
        {
            IVA = 0,
            IGIC = 1,
            NO_SELECCIONADO = 99
        }

        public enum TipoCuenta
        {
            [Description("soportado")]
            SOPORTADO,
            [Description("repercutido")]
            REPERCUTIDO,
            [Description("recargo soportado")]
            RECARGO_SOPORTADO,
            [Description("recargo repercutido")]
            RECARGO_REPERCUTIDO,
            [Description("soportado pendiente de devengo")]
            PTE_SOPORTADO,
            [Description("repercutido pendiente de devengo")]
            PTE_REPERCUTIDO,
            [Description("recargo soportado pendiente de devengo")]
            PTE_RECARGO_SOPORTADO,
            [Description("recargo repercutido pendiente de devengo")]
            PTE_RECARGO_REPERCUTIDO,
            [Description("soportado")]
            PRORRATA_SOPORTADO,
            [Description("soportado pendiente de devengo")]
            PTE_PRORRATA_SOPORTADO
        }

        private string _cCodigoPropuesto;
        private string _cCodigo;
        private string _cCodigoTipoImp;
        private string _cNombre;
        private string _cNombreDefecto;
        private static DataTable _oTiposImpuesto = null;
        private TipoIVA _oTipoIva = null;

        private Decimal _nPorcentaje;
        private Decimal _nRecargo;
        private TipoIVA.TipoImpuesto _oTipo;
        private bool _bDeducible = true;
        private bool _bAplicaRecargo = false;
        private bool _bIGICImplicito = false;
        private bool _bIVAServicios = false;
        private bool _bNoSujeto = false;
        private bool _bIGIC0 = false;
        private bool _bBienesInversion = false;

        //Cuentas
        private string _cCuentaSoportado;
        private string _cCuentaRepercutido;
        private string _cCuentaRecargoSoportado;
        private string _cCuentaRecargoRepercutido;
        //Criterio caja
        private string _cCuentaSoportadoPte;
        private string _cCuentaRepercutidoPte;
        private string _cCuentaRecargoSoportadoPte;
        private string _cCuentaRecargoRepercutidoPte;
        //Prorrata
        private string _cCuentaSoportadoProrrata;
        private string _cCuentaSoportadoProrrataPte;
        //Cuenta propuestas
        private string _cCuentaPropuestaSoportado;
        private string _cCuentaPropuestaRepercutido;
        private string _cCuentaPropuestaRecargoSoportado;
        private string _cCuentaPropuestaRecargoRepercutido;
        private string _cCuentaPropuestaSoportadoPte;
        private string _cCuentaPropuestaRepercutidoPte;
        private string _cCuentaPropuestaRecargoSoportadoPte;
        private string _cCuentaPropuestaRecargoRepercutidoPte;
        private string _cCuentaPropuestaSoportadoProrrata;
        private string _cCuentaPropuestaSoportadoProrrataPte;

        private List<string> _oCuentasPropuestas = new List<string>();
        private string _cErrorMessage;
        private string _cAditionalMessage;

        private Boolean _bCriterioCaja = FUNCTIONS._UtilizaCriterioCaja();

        private BackgroundWorker _oWorker;

        public String _DescripcionTipoImp
        {
            get
            {
                DataRow loRow = _ObtenerTipoImp();

                if (loRow is DataRow)
                {
                    _cCodigoTipoImp = Convert.ToString(loRow["CODIGO"]);

                    return Convert.ToString(loRow["DESCRIP"]);
                }
                else
                {
                    _cCodigoTipoImp = "0";

                    return String.Empty;
                }                
            }
        }

        public TipoIVA _TipoIva
        {
            get
            {
                if (_oTipoIva == null) _oTipoIva = new TipoIVA();
                return _oTipoIva;
            }
            set
            {
                _oTipoIva = value;
            }
        }

        public String _CodigoTipoImp
        {
            get
            {
                return _cCodigoTipoImp;
            }
            set
            {
                if (_cCodigoTipoImp != value)
                {
                    _cCodigoTipoImp = value;

                    List<DataRow> loList = (from loRow in _TiposImpuesto.AsEnumerable()
                                            where Convert.ToString(loRow["CODIGO"]) == _cCodigoTipoImp
                                            select loRow).ToList();

                    if (loList.Count > 0)
                    {
                        _Porcentaje = Convert.ToDecimal(loList.First()["PORC_IMP"]);
                        _Recargo = Convert.ToDecimal(loList.First()["PORC_REC"]);
                        _IGICImplicito = Convert.ToBoolean(loList.First()["IGIC_IMPLI"]);
                        _NoSujeto = Convert.ToBoolean(loList.First()["NOSUJETO"]);
                        if (this._Tipo == TipoIVA.TipoImpuesto.IVA)
                        {
                            _IVA0 = Convert.ToBoolean(loList.First()["CERO"]);
                        }
                        else
                        {
                            _IGIC0 = Convert.ToBoolean(loList.First()["CERO"]);
                        }
                        
                    }
                    else
                    {
                        _Porcentaje = _Recargo = 0;
                        _IGICImplicito = _NoSujeto = false;
                    }
                }
            }
        }

        public String _Codigo
        {
            get
            {
                if (String.IsNullOrEmpty(_cCodigo))
                {
                    _cCodigo = _CodigoPropuesto;
                }
                return _cCodigo;
            }
            set
            {
                _cCodigo = value.PadLeft(_LenCodigo, '0');
            }
        }

        public String _CodigoPropuesto
        {
            get
            {
                if (String.IsNullOrEmpty(_cCodigoPropuesto))
                {
                    _cCodigoPropuesto = _ObtenerCodigo();
                }
                return _cCodigoPropuesto;
            }
        }

        public String _Nombre
        {
            get
            {
                if (String.IsNullOrEmpty(_cNombre)) _cNombre = _NombreXDefecto;               
                return _cNombre;
            }
            set
            {
                _cNombre = value;
                if (String.IsNullOrEmpty(_cNombre.Trim())) _cNombreDefecto = "";
            }
        }

        private String _NombreXDefecto
        {
            get
            {
                if(String.IsNullOrEmpty(_cNombreDefecto)) _cNombreDefecto = String.Format("{0} {1}% {2}", _oTipo, _Porcentaje, _AplicaRecargo && _Recargo > 0 ? String.Format("({0}%)", _Recargo) : "");
                return _cNombreDefecto;
            }
        }

        public void _RefreshNombre()
        {
            if(_cNombre == _cNombreDefecto) _cNombreDefecto = _cNombre = "";
        }

        public Decimal _Porcentaje
        {
            get
            {
                return _nPorcentaje;
            }
            set
            {
                _nPorcentaje = value;
            }
        }

        public Decimal _Recargo
        {
            get
            {
                return _AplicaRecargo ? _nRecargo : 0;
            }
            set
            {
                _nRecargo = value;
            }
        }

        public TipoIVA.TipoImpuesto _Tipo
        {
            get
            {
                return _oTipo;
            }
            set
            {
                _oTipo = value;
            }
        }

        public Boolean _Deducible
        {
            get
            {
                return _bDeducible;
            }
            set
            {
                _bDeducible = value;
            }
        }

        public Boolean _Servicios
        {
            get
            {
                return _bIVAServicios;
            }
            set
            {
                _bIVAServicios = value;
            }
        }

        public Boolean _NoSujeto
        {
            get
            {
                return _bNoSujeto;
            }
            set
            {
                _bNoSujeto = value;
            }
        }

        public Boolean _BienesInversion
        {
            get
            {
                return _bBienesInversion;
            }
            set
            {
                _bBienesInversion = value;
            }
        }

        public Boolean _IGIC0
        {
            get
            {
                return _bIGIC0;
            }
            set
            {
                _bIGIC0 = value;
            }
        }


        public Boolean _IVA0
        {
            get
            {
                return _bIGIC0;
            }
            set
            {
                _bIGIC0 = value;
            }
        }

        public static DataTable _TiposImpuesto
        {
            get
            {
                if (_oTiposImpuesto == null)
                {
                    String lcSql;

                    _oTiposImpuesto = new DataTable();
                    lcSql = String.Format("SELECT '(' + CONVERT(VARCHAR, PORC_IMP) + ') ' + DESCRIP as TITULO, * FROM {0} WHERE ACTIVO = 1 ", DB.SQLDatabase("COMUNES", "TIPOSIMP"));
                    DB.SQLExec(lcSql, ref _oTiposImpuesto);

                    List<DataRow> loListImpli = (from loRow in _oTiposImpuesto.AsEnumerable()
                                                 where Convert.ToBoolean(loRow["IGIC_IMPLI"])
                                                 select loRow).ToList();

                    loListImpli.ForEach(r => r["TITULO"] = String.Format("{0} - Implícito", Convert.ToString(r["TITULO"]).Trim()));
                }
                return _oTiposImpuesto;
            }
        }

        public Boolean _IsPersonalizado
        {
            get
            {
                return _cCodigoTipoImp == "0";
            }
        }

        public Boolean _AplicaRecargo
        {
            get
            {
                return _Tipo == TipoIVA.TipoImpuesto.IVA ? _bAplicaRecargo : false;
            }
            set
            {
                _bAplicaRecargo = value;
            }
        }

        public String _CuentaSoportado
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaSoportado))
                {
                    _cCuentaSoportado = _CuentaPropuestaSoportado;
                }
                return _cCuentaSoportado;
            }
            set
            {
                _cCuentaSoportado = value.Trim();
            }
        }

        public String _CuentaPropuestaSoportado
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaSoportado))
                {
                    _cCuentaPropuestaSoportado = _ObtenerCuenta(_IvaSop);
                }
                return _cCuentaPropuestaSoportado;
            }
        }

        public String _CuentaRepercutido
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaRepercutido))
                {
                    _cCuentaRepercutido = _CuentaPropuestaRepercutido;
                }
                return _cCuentaRepercutido;
            }
            set
            {
                _cCuentaRepercutido = value.Trim();
            }
        }

        public String _CuentaPropuestaRepercutido
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaRepercutido))
                {
                    _cCuentaPropuestaRepercutido = _ObtenerCuenta(_IvaRep);
                }
                return _cCuentaPropuestaRepercutido;
            }
        }

        public String _CuentaRecargoRepercutido
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaRecargoRepercutido))
                {
                    _cCuentaRecargoRepercutido = _CuentaPropuestaRecargoRepercutido;
                }
                return _cCuentaRecargoRepercutido;
            }
            set
            {
                _cCuentaRecargoRepercutido = value.Trim();
            }
        }

        public String _CuentaPropuestaRecargoRepercutido
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaRecargoRepercutido))
                {
                    _cCuentaPropuestaRecargoRepercutido = _ObtenerCuenta(_IvaRecRep);
                }
                return _cCuentaPropuestaRecargoRepercutido;
            }
        }

        public String _CuentaRecargoSoportado
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaRecargoSoportado))
                {
                    _cCuentaRecargoSoportado = _CuentaPropuestaRecargoSoportado;
                }

                return _cCuentaRecargoSoportado;
            }
            set
            {
                _cCuentaRecargoSoportado = value.Trim();
            }
        }

        public String _CuentaPropuestaRecargoSoportado
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaRecargoSoportado))
                {
                    _cCuentaPropuestaRecargoSoportado = _ObtenerCuenta(_IvaRecSop);
                }
                return _cCuentaPropuestaRecargoSoportado;
            }
        }

        public String _CuentaSoportadoPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaSoportadoPte))
                {
                    _cCuentaSoportadoPte = _CuentaPropuestaSoportadoPte;
                }
                return _cCuentaSoportadoPte;
            }
            set
            {
                _cCuentaSoportadoPte = value.Trim();
            }
        }

        public String _CuentaPropuestaSoportadoPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaSoportadoPte))
                {
                    _cCuentaPropuestaSoportadoPte = _ObtenerCuenta(_IvaPendSop);
                }
                return _cCuentaPropuestaSoportadoPte;
            }
        }

        public String _CuentaRepercutidoPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaRepercutidoPte))
                {
                    _cCuentaRepercutidoPte = _CuentaPropuestaRepercutidoPte;
                }
                return _cCuentaRepercutidoPte;
            }
            set
            {
                _cCuentaRepercutidoPte = value.Trim();
            }
        }

        public String _CuentaPropuestaRepercutidoPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaRepercutidoPte))
                {
                    _cCuentaPropuestaRepercutidoPte = _ObtenerCuenta(_IvaRecPendRep);
                }
                return _cCuentaPropuestaRepercutidoPte;
            }
        }

        public String _CuentaRecargoRepercutidoPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaRecargoRepercutidoPte))
                {
                    _cCuentaRecargoRepercutidoPte = _CuentaPropuestaRecargoRepercutidoPte;
                }
                return _cCuentaRecargoRepercutidoPte;
            }
            set
            {
                _cCuentaRecargoRepercutidoPte = value.Trim();
            }
        }

        public String _CuentaPropuestaRecargoRepercutidoPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaRecargoRepercutidoPte))
                {
                    _cCuentaPropuestaRecargoRepercutidoPte = _ObtenerCuenta(_IvaRecPendRep);
                }
                return _cCuentaPropuestaRecargoRepercutidoPte;
            }
        }

        public String _CuentaRecargoSoportadoPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaRecargoSoportadoPte))
                {
                    _cCuentaRecargoSoportadoPte = _CuentaPropuestaRecargoSoportadoPte;
                }

                return _cCuentaRecargoSoportadoPte;
            }
            set
            {
                _cCuentaRecargoSoportadoPte = value.Trim();
            }
        }

        public String _CuentaPropuestaRecargoSoportadoPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaRecargoSoportadoPte))
                {
                    _cCuentaPropuestaRecargoSoportadoPte = _ObtenerCuenta(_IvaRecPendSop);
                }
                return _cCuentaPropuestaRecargoSoportadoPte;
            }           
        }

        public String _CuentaSoportadoProrrata
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaSoportadoProrrata))
                {
                    _cCuentaSoportadoProrrata = _CuentaPropuestaSoportadoProrrata;
                }
                return _cCuentaSoportadoProrrata;
            }
            set
            {
                _cCuentaSoportadoProrrata = value.Trim();
            }
        }

        public String _CuentaPropuestaSoportadoProrrata
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaSoportadoProrrata))
                {
                    _cCuentaPropuestaSoportadoProrrata = _ObtenerCuenta(_IvaProrrataSop);
                }
                return _cCuentaPropuestaSoportadoProrrata;
            }
        }

        public String _CuentaSoportadoProrrataPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaSoportadoProrrataPte))
                {
                    _cCuentaSoportadoProrrataPte = _CuentaPropuestaSoportadoProrrataPte;
                }
                return _cCuentaSoportadoProrrataPte;
            }
            set
            {
                _cCuentaSoportadoProrrataPte = value.Trim();
            }
        }

        public String _CuentaPropuestaSoportadoProrrataPte
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaPropuestaSoportadoProrrataPte))
                {
                    _cCuentaPropuestaSoportadoProrrataPte = _ObtenerCuenta(_IvaProrrataPendSop);
                }
                return _cCuentaPropuestaSoportadoProrrataPte;
            }
        }

        public String _ErroMessage
        {
            get
            {
                return _cErrorMessage;
            }
            private set
            {
                _cErrorMessage = value;
            }
        }

        public Boolean _Prorrata
        {
            get
            {
                return Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prorrata_aplicar"));
            }
        }

        public Boolean _IGICImplicito
        {
            get
            {
                return _bIGICImplicito;
            }
            set
            {
                _bIGICImplicito = value;
            }
        }

        public Boolean _CriterioCaja
        {
            get
            {
                return _bCriterioCaja;
            }
        }        
        
        private String _ObtenerCuenta(TipoCuenta toTipoCuenta)
        {
            String tcCuenta;

            switch (toTipoCuenta)
            {
                case TipoCuenta.SOPORTADO:
                    tcCuenta = _IvaSop;
                    break;
                case TipoCuenta.REPERCUTIDO:
                    tcCuenta = _IvaRep;
                    break;
                case TipoCuenta.RECARGO_SOPORTADO:
                    tcCuenta = _IvaRecSop;
                    break;
                case TipoCuenta.RECARGO_REPERCUTIDO:
                    tcCuenta = _IvaRecRep;
                    break;
                case TipoCuenta.PTE_SOPORTADO:
                    tcCuenta = _IvaPendSop;
                    break;
                case TipoCuenta.PTE_REPERCUTIDO:
                    tcCuenta = _IvaPendRep;
                    break;
                case TipoCuenta.PTE_RECARGO_SOPORTADO:
                    tcCuenta = _IvaRecPendSop;
                    break;
                case TipoCuenta.PTE_RECARGO_REPERCUTIDO:
                    tcCuenta = _IvaRecPendSop;
                    break;
                case TipoCuenta.PRORRATA_SOPORTADO:
                    tcCuenta = _IvaProrrataSop;
                    break;
                case TipoCuenta.PTE_PRORRATA_SOPORTADO:
                    tcCuenta = _IvaProrrataPendSop;
                    break;
                default:
                    tcCuenta = "";
                    break;
            }

            return _ObtenerCuenta(tcCuenta);
        }

        private String _ObtenerCuenta(String tcCuenta)
        {
            String lcSql;
            DataTable loDt = new DataTable();
            Boolean lbAdd = true;

            lcSql = String.Format("SELECT CODIGO as CODIGO FROM {0} WHERE LEFT(CODIGO, 3 ) = {1} ", DB.SQLDatabase("GESTION", "CUENTAS"), DB.SQLString(tcCuenta.Substring(0, 3)));
            DB.SQLExec(lcSql, ref loDt);

            while (lbAdd)
            {
                tcCuenta = Convert.ToString(Convert.ToInt64(tcCuenta) + 1);

                List<String> loList = (from loRow in loDt.AsEnumerable()
                                       where Convert.ToString(loRow["CODIGO"]).Trim() == tcCuenta.Trim()
                                       select Convert.ToString(loRow["CODIGO"])).ToList();

                if (loList.Count == 0)
                {
                    loList = (from lcCuenta in _oCuentasPropuestas
                                           where lcCuenta.Trim() == tcCuenta.Trim()
                                           select lcCuenta).ToList();

                    if (loList.Count == 0)
                    {
                        _oCuentasPropuestas.Add(tcCuenta.Trim());
                        lbAdd = false;
                    }                    
                }
            }

            return tcCuenta;
        }

        public BackgroundWorker _BackgroundWorker
        {
            get
            {
                return _oWorker;
            }
            set
            {
                _oWorker = value;
            }
        }       

        public Boolean _Finalizar()
        {
            Int32 lnContMax = 3;
            Int32 lnContProcess = 0;
            
            if (_Prorrata ) lnContMax = lnContMax + (_CriterioCaja ? 2 : 1);
            if (_CriterioCaja) lnContMax = lnContMax + 2;
            if (_AplicaRecargo && _Recargo > 0) lnContMax = lnContMax + (_CriterioCaja ? 4 : 2);

            _cErrorMessage = "";

            _SetProcess(ref lnContProcess, ref lnContMax, "Creando cuentas contables");

            try
            {
                if (_CuentaSoportado == _CuentaPropuestaSoportado)
                {
                    if (!_CreaCuenta(ref _cCuentaSoportado, ref lnContProcess, lnContMax, TipoCuenta.SOPORTADO))
                    {
                        throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.SOPORTADO.__GetDescription()));
                    }
                }

                if (_CuentaRepercutido == _CuentaPropuestaRepercutido)
                {
                    if(!_CreaCuenta(ref _cCuentaRepercutido, ref lnContProcess, lnContMax, TipoCuenta.REPERCUTIDO))
                    {
                        throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.REPERCUTIDO.__GetDescription()));
                    }
                }

                //Cuentas de recargo
                if (_AplicaRecargo && _Recargo > 0)
                {
                    if (_CuentaRecargoSoportado == _CuentaPropuestaRecargoSoportado)
                    {
                        if (!_CreaCuenta(ref _cCuentaRecargoSoportado, ref lnContProcess, lnContMax, TipoCuenta.RECARGO_SOPORTADO))
                        {
                            throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.RECARGO_SOPORTADO.__GetDescription()));
                        }
                    }

                    if (_CuentaRecargoRepercutido == _CuentaPropuestaRecargoRepercutido)
                    {
                        if (!_CreaCuenta(ref _cCuentaRecargoRepercutido, ref lnContProcess, lnContMax, TipoCuenta.RECARGO_REPERCUTIDO))
                        {
                            throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.RECARGO_REPERCUTIDO.__GetDescription()));
                        }
                    }
                }

                // Cuentas de criterio de caja
                if (_CriterioCaja)
                {
                    if (_CuentaSoportadoPte == _CuentaPropuestaSoportadoPte)
                    {
                        if (!_CreaCuenta(ref _cCuentaSoportadoPte, ref lnContProcess, lnContMax, TipoCuenta.PTE_SOPORTADO))
                        {
                            throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.PTE_SOPORTADO.__GetDescription()));
                        }
                    }

                    if (_CuentaRepercutidoPte == _CuentaPropuestaRepercutidoPte)
                    {
                        if(!_CreaCuenta(ref _cCuentaRepercutidoPte, ref lnContProcess, lnContMax, TipoCuenta.PTE_REPERCUTIDO))
                        {
                            throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.PTE_REPERCUTIDO.__GetDescription()));
                        }
                    }

                    //Cuentas de recargo
                    if (_AplicaRecargo && _Recargo > 0)
                    {
                        if (_CuentaRecargoSoportadoPte == _CuentaPropuestaRecargoSoportadoPte)
                        {
                            if(!_CreaCuenta(ref _cCuentaRecargoSoportadoPte, ref lnContProcess, lnContMax, TipoCuenta.PTE_RECARGO_SOPORTADO))
                            {
                                throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.PTE_RECARGO_SOPORTADO.__GetDescription()));
                            }
                        }

                        if (_CuentaRecargoRepercutidoPte == _CuentaPropuestaRecargoRepercutidoPte)
                        {
                            if(!_CreaCuenta(ref _cCuentaRecargoRepercutidoPte, ref lnContProcess, lnContMax, TipoCuenta.PTE_RECARGO_REPERCUTIDO))
                            {
                                throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.PTE_RECARGO_REPERCUTIDO.__GetDescription()));
                            }
                        }
                    }
                }

                //Cuentas de prorrata
                if (_Prorrata)
                {
                    if (_CuentaSoportadoProrrata == _CuentaPropuestaSoportadoProrrata)
                    {
                        if (!_CreaCuenta(ref _cCuentaSoportadoProrrata, ref lnContProcess, lnContMax, TipoCuenta.PRORRATA_SOPORTADO))
                        {
                            throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.PRORRATA_SOPORTADO.__GetDescription()));
                        }
                    }

                    // Cuentas de criterio de caja
                    if (_CriterioCaja)
                    {
                        if (_CuentaSoportadoProrrataPte == _CuentaPropuestaSoportadoProrrataPte)
                        {
                            if (!_CreaCuenta(ref _cCuentaSoportadoProrrataPte, ref lnContProcess, lnContMax, TipoCuenta.PTE_PRORRATA_SOPORTADO))
                            {
                                throw new Exception(String.Format("Se ha producido un problema al crear la cuenta de {0}", TipoCuenta.PTE_PRORRATA_SOPORTADO.__GetDescription()));
                            }
                        }
                    }
                }

                _SetProcess(ref lnContProcess, ref lnContMax, "", "Cuentas contables creadas correctamente.");

                if (!_CreaIva(lnContMax))
                {
                    throw new Exception(String.Format("Se ha producido un problema al crear el tipo de  {0}", _oTipo));
                }
                
            }
            catch (Exception loEx)
            {
                _cErrorMessage = loEx.Message;
                _SetProcess(ref lnContMax, ref lnContMax, "", String.Format("Se ha producido un error: {0}", _cErrorMessage));

                return false;
            }

            return true;
        }

        private void _SetProcess(ref Int32 lnContProcess, ref Int32 lnContMax, String tcTexto, String tcTextoTextBox = "")
        {
            if (!String.IsNullOrEmpty(tcTexto)) lnContProcess++;
            _BackgroundWorker.ReportProgress(lnContProcess, new InfoProgresBar(lnContProcess, lnContMax, tcTexto, tcTextoTextBox));

            //Paramos el thread para que refresque
            Thread.Sleep(300);
        }

        private Boolean _CreaIva(Int32 tnContMax)
        {
            Boolean bCreated = false;
            Int32 lnCont = 1;
            String lcCodigoTmp;
            Int32 lnContMax = tnContMax - 1;

            _SetProcess(ref lnContMax, ref tnContMax, String.Format("Creando tipo de {0}", _oTipo), "");

            while (!bCreated && lnCont < 10)
            {
                lnCont++;
                lcCodigoTmp = _Codigo;
                _cAditionalMessage = "";

                _TipoIva = new TipoIVA();
                _TipoIva._Codigo = _Codigo;

                if (!_TipoIva._Existe_Registro())
                {
                    _TipoIva._Nombre = _Nombre;
                    _TipoIva._IVA = _Porcentaje;
                    _TipoIva._Recargo = _Recargo;
                    _TipoIva._IVA_Deducible = _Deducible;
                    _TipoIva._IVA_Servicios = _Servicios;
                    _TipoIva._IVA_Exento = _NoSujeto;
                    _TipoIva._IVA_BienesInversion = _BienesInversion;
                    _TipoIva._Tipo = _Tipo;
                    _TipoIva._IGICImplicito = _Tipo == TipoIVA.TipoImpuesto.IGIC ? _IGICImplicito : false;
                    if (_Tipo == TipoIVA.TipoImpuesto.IGIC)
                        _TipoIva._IGIC_Sujeto0 = _IGIC0;
                    else
                        _TipoIva._IVA_Sujeto0 = _IVA0;


                    DataRow loRow = _ObtenerTipoImp();

                    if(loRow is DataRow) _TipoIva._Tipo_Imp = Convert.ToInt32(loRow["CODIGO"]);

                    //Cuentas
                    _TipoIva._Cta_IVA_Sop = _CuentaSoportado;
                    _TipoIva._Cta_IVA_Rep = _CuentaRepercutido;

                    if (_AplicaRecargo && _Recargo > 0)
                    {
                        _TipoIva._Cta_REC_Sop = _CuentaRecargoSoportado;
                        _TipoIva._Cta_REC_Rep = _CuentaRecargoRepercutido;
                    }

                    if(_CriterioCaja)
                    {
                        _TipoIva._Pendedsop = _CuentaSoportadoPte;
                        _TipoIva._Pendevrep = _CuentaRepercutidoPte;

                        if (_AplicaRecargo && _Recargo > 0)
                        {
                            _TipoIva._Recsopcdev = _CuentaRecargoSoportadoPte;
                            _TipoIva._Recrepcdev = _CuentaRecargoRepercutidoPte;
                        }
                    }

                    if (_Prorrata)
                    {
                        _TipoIva._Cta_IVA_Sop_Nodeduc = _CuentaSoportadoProrrata;
                        if (_CriterioCaja) _TipoIva._Pendedsop_Nodeduc = _CuentaSoportadoProrrataPte;
                    }

                    if (DB._EsPenultimoEjercicio()) _TipoIva._OnMessageTraspasoPenultimoEjercicio += Cuenta__OnMessageTraspasoPenultimoEjercicio;

                    if (_TipoIva._Save_Before())
                    {
                        if (!_TipoIva._Save())
                        {
                            _Codigo = _ObtenerCodigo();

                            _cErrorMessage = String.Format("No se ha podido crear el tipo de {0} con código {1}, se asignará el nuevo código {2}.", _oTipo, lcCodigoTmp, _Codigo);
                            _SetProcess(ref lnContMax, ref tnContMax, "", _cErrorMessage);
                        }
                        else
                        {
                            bCreated = true;
                        }
                    }
                    else
                    {
                        lnCont = 10;

                        _cErrorMessage = String.Format("No se ha podido crear el tipo de {0} con código {1}, se ha producido un error al validar los datos : {2}", _oTipo, lcCodigoTmp, _TipoIva._Error_Message);
                        _SetProcess(ref lnContMax, ref tnContMax, "", _cErrorMessage);
                    }

                    if (DB._EsPenultimoEjercicio()) _TipoIva._OnMessageTraspasoPenultimoEjercicio -= Cuenta__OnMessageTraspasoPenultimoEjercicio;

                }
                else
                {
                    _Codigo = _ObtenerCodigo();
                    _cErrorMessage = String.Format("No se ha podido crear el tipo de {0} con código {1}, se asignará el nuevo código {2}.", _oTipo, lcCodigoTmp, _Codigo);
                    _SetProcess(ref lnContMax, ref tnContMax, "", _cErrorMessage);
                }
            }

            if (bCreated)
            {
                _SetProcess(ref lnContMax, ref tnContMax, "", String.Format("Tipo de {0} creado correctamente con código {1}.", _oTipo, _Codigo));
                if (!string.IsNullOrEmpty(_cAditionalMessage)) _SetProcess(ref lnContMax, ref tnContMax, "", _cAditionalMessage);
            }
            
            return bCreated;
        }

        private DataRow _ObtenerTipoImp()
        {
            List<DataRow> loTipos = (from loRow in _TiposImpuesto.AsEnumerable()
                                     where
                                         Convert.ToDecimal(loRow["PORC_IMP"]) == _Porcentaje &&
                                         Convert.ToInt32(loRow["TIPO"]) == Convert.ToInt32(_oTipo) &&
                                         Convert.ToBoolean(loRow["NOSUJETO"]) == _NoSujeto &&
                                         Convert.ToBoolean(loRow["IGIC_IMPLI"]) == _IGICImplicito &&
                                         Convert.ToBoolean(loRow["CERO"]) == (_Tipo == TipoIVA.TipoImpuesto.IVA ? _IVA0 :_IGIC0) 
                                     select loRow).ToList();

            return loTipos.Count > 0 ? loTipos.First() : null;
        }

        private Boolean _CreaCuenta(ref String tcCuenta, ref Int32 tnContProcess, Int32 tnContMax, TipoCuenta toTipo )
        {
            Cuenta loCuenta;
            Boolean bCreated = false;
            String tcCuentaTmp, lcNombre = "";
            Int32 lnCont = 1;

            _SetProcess(ref tnContProcess, ref tnContMax, String.Format("Creando cuenta {0}", tcCuenta));

            while (!bCreated && lnCont < 10)
            {
                _cAditionalMessage = "";
                tcCuentaTmp = tcCuenta;
                lnCont++;

                loCuenta = new Cuenta(tcCuenta);

                if (!loCuenta._Existe_Registro())
                {
                    lcNombre = String.Format("{0} {1}", _oTipo, toTipo.__GetDescription());
                    loCuenta._Nombre = lcNombre.ToUpper();
                    //Añadimos el mensaje si se traspasa al año siguiente
                    if (DB._EsPenultimoEjercicio()) loCuenta._OnMessageTraspasoPenultimoEjercicio += Cuenta__OnMessageTraspasoPenultimoEjercicio;

                    if (!loCuenta._Save())
                    {
                        tcCuenta = _ObtenerCuenta(toTipo);
                        _cErrorMessage = String.Format("No se ha podido crear la cuenta {0}, se asignará la cuenta {1}.", tcCuentaTmp, tcCuenta);
                        _SetProcess(ref tnContProcess, ref tnContMax, "", _cErrorMessage);
                    }
                    else
                    {
                        bCreated = true;
                    }                    
                }
                else
                {
                    tcCuenta = _ObtenerCuenta(toTipo);

                    _cErrorMessage = String.Format("No se ha podido crear la cuenta {0} porque ya existe, se asignará la cuenta {1}.", tcCuentaTmp, tcCuenta);
                    _SetProcess(ref tnContProcess, ref tnContMax, "", _cErrorMessage);                    
                }

                if (DB._EsPenultimoEjercicio()) loCuenta._OnMessageTraspasoPenultimoEjercicio -= Cuenta__OnMessageTraspasoPenultimoEjercicio;

            }

            if (bCreated)
            {
                _SetProcess(ref tnContProcess, ref tnContMax, "", String.Format("Cuenta {0} {1} creada correctamente.", tcCuenta, lcNombre));
                if(!string.IsNullOrEmpty(_cAditionalMessage)) _SetProcess(ref tnContProcess, ref tnContMax, "", _cAditionalMessage);
            }
            
            return bCreated;
        }

        private bool Cuenta__OnMessageTraspasoPenultimoEjercicio(enumerations.AccionTraspasoUltimoEjercicio toAccion, bool tbIsNew, string tcNextEjer, string tcMessage)
        {
            _cAditionalMessage = tcMessage;

            return true;
        }

        private String _ObtenerCodigo()
        {
            String lcMax = "1";    
            String lcSql = "";
            DataTable loDt = new DataTable();

            lcSql = String.Format("SELECT CODIGO FROM {0} WHERE CODIGO <> '' ORDER BY CODIGO ASC ", DB.SQLDatabase("GESTION", "TIPO_IVA"));
            DB.SQLExec(lcSql, ref loDt);

            if (loDt.Rows.Count > 0)
            {
                foreach (DataRow loRow in loDt.Rows)
                {
                    lcMax = Convert.ToString(loRow["CODIGO"]);
                    lcMax = _ObtenerSiguiente(lcMax);

                    Boolean lbExist = (from loRowCodigo in loDt.AsEnumerable()
                                       where Convert.ToString(loRowCodigo["CODIGO"]) == lcMax
                                       select loRowCodigo).Count() > 0;

                    if (!lbExist) return lcMax;
                }
            }
            else
            {
                lcMax = lcMax.PadLeft(_LenCodigo, '0');
            }

            return lcMax;
        }

        public Boolean _ValidaCodigo(String tcCodigo)
        {
            String lcSql = "";
            DataTable loDt = new DataTable();

            lcSql = String.Format("SELECT CODIGO FROM {0} WHERE CODIGO = {1}", DB.SQLDatabase("GESTION", "TIPO_IVA"), DB.SQLString(tcCodigo));
            DB.SQLExec(lcSql, ref loDt);

            return loDt.Rows.Count == 0;
        }

        private String _ObtenerSiguiente(String tcNum)
        {
            String tcNewNum = tcNum;

            if (!_ObtenerSiguienteNum(ref tcNewNum))
            {
                tcNewNum = _ObtenerSiguiente(tcNum.ToCharArray());
            }

            return tcNewNum;
        }

        private bool _ObtenerSiguienteNum(ref String tcNum)
        {
            Int32 lnTmp, lnMax = 0;
            Int32 lnLenght = tcNum.Length;

            lnMax = (Int32)Math.Pow(10, tcNum.Length) - 1;

            if (Int32.TryParse(tcNum, out lnTmp) && (lnTmp + 1) <= lnMax)
            {
                tcNum = Convert.ToString(lnTmp + 1);
                tcNum = tcNum.PadLeft(lnLenght, '0');

                return true;
            }

            return false;
        }

        private String _ObtenerSiguiente(Char[] loChars)
        {
            if (loChars.Length > 0)
            {
                String lcNum = new String(loChars);
                String lcNumTmp, lcPrefix, lcNextPrefix;

                lcNumTmp = lcNum.Substring(1);
                lcPrefix = lcNum.Substring(0, 1);
                Char[] loPrefix = lcPrefix.ToCharArray();

                if (lcPrefix == "9")
                {
                    lcNextPrefix = "A";
                }
                else if (Char.IsLetter(lcPrefix.ToCharArray()[0]) && lcPrefix.ToCharArray()[0] < (Char)'Z')
                {
                    loPrefix[0] = (Char)(loPrefix[0] + 1);
                    lcNextPrefix = new String(loPrefix);
                }
                else if(Char.IsLetter(lcPrefix.ToCharArray()[0]) && lcPrefix.ToCharArray()[0] == (Char)'Z')
                {
                    lcNextPrefix = "Z";
                }
                else
                {
                    lcNextPrefix = Convert.ToString(Convert.ToInt32(lcPrefix) + 1);
                }

                if (!String.IsNullOrEmpty(lcNumTmp))
                {
                    if (!_ObtenerSiguienteNum(ref lcNumTmp))
                    {
                        if (lcNextPrefix == "Z")
                        {
                            return "Z" + _ObtenerSiguiente(lcNumTmp.ToCharArray());
                        }
                        else
                        {
                            return lcNextPrefix + "0".PadRight(loChars.Length - 1, '0');
                        }
                    }
                    else
                    {
                        return lcPrefix + lcNumTmp;
                    }
                }
                else
                {
                    return lcNextPrefix;
                }
            }

            return new String(loChars);
        }

        public static DataTable _ObtenerTipos(TipoImpuesto toTipoImpuesto)
        {
            DataTable loDt = (from loRow in _TiposImpuesto.AsEnumerable()
                              where Convert.ToInt32(loRow["TIPO"]) == Convert.ToInt32(toTipoImpuesto)
                              select loRow).CopyToDataTable();

            DataRow loRowPersonalizado = loDt.NewRow();
            loRowPersonalizado["CODIGO"] = 0;
            loRowPersonalizado["TITULO"] = "Personalizado";
            loDt.Rows.Add(loRowPersonalizado);

            return loDt;
        }

        public Boolean _ComprobarIva(String tcValorCandidato, TipoCuenta toTipoCuenta)
        {
            _cErrorMessage = "";

            String lcCuentaPropuesta, lcPrefijo;

            switch(toTipoCuenta)
            {
                case TipoCuenta.SOPORTADO:
                    lcCuentaPropuesta = _CuentaPropuestaSoportado;
                    lcPrefijo = _IvaSop3;
                    break;
                case TipoCuenta.REPERCUTIDO:
                    lcCuentaPropuesta = _CuentaPropuestaRepercutido;
                    lcPrefijo = _IvaRep3;
                    break;
                case TipoCuenta.RECARGO_SOPORTADO:
                    lcCuentaPropuesta = _CuentaPropuestaRecargoSoportado;
                    lcPrefijo = _IvaRecSop3;
                    break;
                case TipoCuenta.RECARGO_REPERCUTIDO:
                    lcCuentaPropuesta = _CuentaPropuestaRecargoRepercutido;
                    lcPrefijo = _IvaRecRep3;
                    break;
                case TipoCuenta.PTE_SOPORTADO:
                    lcCuentaPropuesta = _CuentaPropuestaSoportadoPte;
                    lcPrefijo = _IvaPendSop3;
                    break;
                case TipoCuenta.PTE_REPERCUTIDO:
                    lcCuentaPropuesta = _CuentaPropuestaRepercutidoPte;
                    lcPrefijo = _IvaPendRep3;
                    break;
                case TipoCuenta.PTE_RECARGO_SOPORTADO:
                    lcCuentaPropuesta = _CuentaPropuestaRecargoSoportadoPte;
                    lcPrefijo = _IvaRecPendSop3;
                    break;
                case TipoCuenta.PTE_RECARGO_REPERCUTIDO:
                    lcCuentaPropuesta = _CuentaPropuestaRecargoRepercutidoPte;
                    lcPrefijo = _IvaRecPendSop3;
                    break;
                case TipoCuenta.PRORRATA_SOPORTADO:
                    lcCuentaPropuesta = _CuentaPropuestaSoportadoProrrata;
                    lcPrefijo = "";
                    break;
                case TipoCuenta.PTE_PRORRATA_SOPORTADO:
                    lcCuentaPropuesta = _CuentaPropuestaSoportadoProrrataPte;
                    lcPrefijo = "";
                    break;
                default:
                    lcCuentaPropuesta = lcPrefijo = "";
                    break;
            }

            if (!String.IsNullOrEmpty(tcValorCandidato) && tcValorCandidato != lcCuentaPropuesta)
            {
                if (!String.IsNullOrEmpty(lcPrefijo) && !tcValorCandidato.StartsWith(lcPrefijo))
                {
                    _cErrorMessage = String.Format("La cuenta debe comenzar por {0}.", lcPrefijo);                   
                }
                else if(!_Existe_Codigo(tcValorCandidato))
                {
                    _cErrorMessage = String.Format("La cuenta {0} no existe.", tcValorCandidato);
                }
                else if (_CuentaAsignada(tcValorCandidato))
                {
                    _cErrorMessage = _ErroMessage;
                }
                else if (_ComprobarIvas(toTipoCuenta, tcValorCandidato))
                {
                    _cErrorMessage = _ErroMessage;                   
                }
            }

            return String.IsNullOrEmpty(_cErrorMessage);
        }

        private Boolean _CuentaAsignada(String tcValorCandidato)
        {   
            if (tcValorCandidato == _CuentaSoportado)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de {1} soportado.", tcValorCandidato, _Tipo);
            }
            else if (tcValorCandidato == _CuentaRepercutido)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de {1} repercutido.", tcValorCandidato, _Tipo);
            }
            else if (_AplicaRecargo && tcValorCandidato == _CuentaRecargoSoportado)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de recargo soportado.", tcValorCandidato);
            }
            else if (_AplicaRecargo && tcValorCandidato == _CuentaRecargoRepercutido)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de recargo repercutido.", tcValorCandidato);
            }
            else if (_CriterioCaja && tcValorCandidato == _CuentaSoportadoPte)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de soportado pendiente de devengo.", tcValorCandidato);
            }
            else if (_CriterioCaja && tcValorCandidato == _CuentaRepercutidoPte)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de repercutido pendiente de devengo.", tcValorCandidato);
            }
            else if (_CriterioCaja && _AplicaRecargo && tcValorCandidato == _CuentaRecargoSoportadoPte)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de recargo soportado pendiente de devengo.", tcValorCandidato);
            }
            else if (_CriterioCaja && _AplicaRecargo && tcValorCandidato == _CuentaRecargoRepercutidoPte)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de recargo repercutido pendiente de devengo.", tcValorCandidato);
            }
            else if (_Prorrata && tcValorCandidato == _cCuentaSoportadoProrrata)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de soportado no deducible.", tcValorCandidato);
            }
            else if (_Prorrata && _CriterioCaja  && tcValorCandidato == _CuentaSoportadoProrrataPte)
            {
                _cErrorMessage = String.Format("La cuenta {0} ya esta asignada a la cuenta de soportado no deducible pendiente de devengo.", tcValorCandidato);
            }

            return !String.IsNullOrEmpty(_cErrorMessage);
        }

        private bool _Existe_Codigo(string tcValorCandidato)
        {
            Cuenta loCuenta = new Cuenta();
            loCuenta._Codigo = tcValorCandidato;
            return loCuenta._Existe_Registro();
        }

        private Boolean _ComprobarIvas(TipoCuenta toTipoCuenta, String tcValorCandidato)
        {
            String lcMessage = "";
            Boolean lbOk = true;
            String lcTipo = Convert.ToString(_Tipo);

            switch (toTipoCuenta)
            {
                case TipoCuenta.SOPORTADO:
                    lbOk = _TipoIva._Comprobar_Ctas_Iva(lcTipo, tcValorCandidato, "", "", "", "", "", "", "", out lcMessage);
                    break;
                case TipoCuenta.REPERCUTIDO:
                    lbOk = _TipoIva._Comprobar_Ctas_Iva(lcTipo, "", tcValorCandidato, "", "", "", "", "", "", out lcMessage);
                    break;
                case TipoCuenta.RECARGO_SOPORTADO:
                    lbOk = _TipoIva._Comprobar_Ctas_Iva(lcTipo, "", "", tcValorCandidato, "", "", "", "", "", out lcMessage);
                    break;
                case TipoCuenta.RECARGO_REPERCUTIDO:
                    lbOk = _TipoIva._Comprobar_Ctas_Iva(lcTipo, "", "", "", tcValorCandidato, "", "", "", "", out lcMessage);
                    break;
                case TipoCuenta.PTE_SOPORTADO:
                    lbOk = _TipoIva._Comprobar_Ctas_Iva(lcTipo, "", "", "", "", tcValorCandidato, "", "", "", out lcMessage);
                    break;
                case TipoCuenta.PTE_REPERCUTIDO:
                    lbOk = _TipoIva._Comprobar_Ctas_Iva(lcTipo, "", "", "", "", "", tcValorCandidato, "", "", out lcMessage);
                    break;
                case TipoCuenta.PTE_RECARGO_SOPORTADO:
                    lbOk = _TipoIva._Comprobar_Ctas_Iva(lcTipo, "", "", "", "", "", "", tcValorCandidato, "", out lcMessage);
                    break;
                case TipoCuenta.PTE_RECARGO_REPERCUTIDO:
                    lbOk = _TipoIva._Comprobar_Ctas_Iva(lcTipo, "", "", "", "", "", "", "", tcValorCandidato, out lcMessage);
                    break;
            }

            _ErroMessage = lcMessage;

            return lbOk;
        }

        public DatosIva()
        {
            _oTipo = Convert.ToString(EW_GLOBAL._GetVariable("wc_iva")) == "IVA" ? TipoIVA.TipoImpuesto.IVA : TipoIVA.TipoImpuesto.IGIC; ;
        }
    }

    public class DatosAsiententeIvaBase
        : UserControl
    {
        protected DatosIva _oDatos;
        protected String _cErrorMessage = "";

        public virtual DatosIva _DatosIva
        {
            get
            {
                return _oDatos;
            }
            set
            {
                _oDatos = value;
            }
        }

        public String _ErrorMessage
        {
            get
            {
                return _cErrorMessage;
            }
        }

        public virtual Boolean _ValidaSiguiente()
        {
            return true;
        }

        public virtual void _RemoveBinding()
        {

        }
    }

    public interface IDatosAsiententeIva
    {
        DatosIva _DatosIva { get; set; }

        String _ErrorMessage { get; }

        Boolean _ValidaSiguiente();

        void _RemoveBinding();
    }
}