clsLetras.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using sage.ew.db;
using sage.ew.ewbase;
using System.Data;
using System.ComponentModel;
using sage.ew.global;
using sage.ew.tpv;
using sage.ew.functions;
using System.Text.RegularExpressions;

namespace sage.ew.docsven
{
    public class Letras : ewMante, INotifyPropertyChanged
    {
        // Cumplimiento de interficie
        //
        #region INotifyPropertyChanged

        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(String info)
        {
            var handler = PropertyChanged; //ThreadSafe
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

        #endregion INotifyPropertyChanged

        #region PROPIEDADES PRIVADAS
        private DataTable _dtEmpresas = new DataTable();

        private DataTable ldtEmpModelos;

        private string _cEmpresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));

        #endregion

        #region PROPIEDADES PUBLICAS

        public readonly string _Modelo340 = "340";

        public DataTable _dtEmpModelos
        {
            get { return ldtEmpModelos; }
            set { ldtEmpModelos = value; }
        }

        public bool _Fact_Rect
        {
            get
            {
                if (_lisCampos.ContainsKey("FACT_RECT"))
                    return Convert.ToBoolean(_lisCampos["FACT_RECT"]._NewVal);
                else
                    return false;
            }
            set
            {
                if (_lisCampos.ContainsKey("FACT_RECT"))
                {
                    string lcMensaje = "";
                    if (Convert.ToBoolean(_lisCampos["FACT_RECT"]._NewVal) && !value && _SerieRectificativaConfiguradaDefecto(this._Codigo, ref lcMensaje))
                    {
                        _Error_Message = "No es posible desmarcar la opción 'Serie para facturas rectificativas', " +
                                         "puesto que esta serie ya ha sido configurada por defecto "+ lcMensaje;                        
                        NotifyPropertyChanged("_Fact_Rect");
                        return;
                    }

                    if (Convert.ToBoolean(_lisCampos["FACT_RECT"]._NewVal) && !value && 
                        this._Estado == _EstadosMantenimiento.EditandoRegistro &&
                        existenFacturasConSerie())
                    {
                        _Error_Message = "No es posible desmarcar la opción 'Serie para facturas rectificativas', puesto que esta serie ya se ha utilizado en alguna factura.";
                        NotifyPropertyChanged("_Fact_Rect");
                        return;
                    }

                    _lisCampos["FACT_RECT"]._NewVal = value;
                }

                _Exportar_Null();
            }
        }

        //PE-102341
        public override string _Codigo
        {
            get
            {
                return base._Codigo;
            }
            set
            {
                //PE-102341 No permitimos espacios por la derecha.
                if (value != null)
                    value = value.TrimStart();

                base._Codigo = value;

                // Cargar la información de empresas de modelo
                _ObtenerEmpresasModelo();
            }
        }

        public bool _Opera_AJ
        {
            get
            {
                if (_lisCampos.ContainsKey("OPERA_AJ"))
                    return Convert.ToBoolean(_lisCampos["OPERA_AJ"]._NewVal);
                else
                    return false;
            }
            set
            {
                if (_lisCampos.ContainsKey("OPERA_AJ"))
                    _lisCampos["OPERA_AJ"]._NewVal = value;
                
                _Exportar_Null();
            }
        }

        #endregion PROPIEDADES


        #region CONSTRUCTORS

        public Letras()
        {
            // Asignamos las propiedades para Letras
            this._lTodos = true;
            this._Clave = "Codigo";
            this._DataBase = "Comunes";
            this._Tabla = "letras";
            this._TituloMantenimiento = "Series de documentos"; // PE-91891. Cambiar el título

            this._Pantalla = "LETRAS";
            this._FormManteBaseType = typeof(sage.ew.formul.Forms.frmLetras); // PE-104369

            this._Codigo = string.Empty; // PE-104369
        }

        public Letras(string tcLetra)
        {
            // Asignamos las propiedades para Letras
            this._lTodos = true;
            this._Clave = "Codigo";
            this._DataBase = "Comunes";
            this._Tabla = "letras";
            this._TituloMantenimiento = "Series de documentos";

            this._Pantalla = "LETRAS";
            this._FormManteBaseType = typeof(sage.ew.formul.Forms.frmLetras);

            this._Codigo = tcLetra;
            this._Load();
        }

        #endregion


        #region METODOS PUBLICOS

        public bool _EsRectificativa(string tcEmpresa)
        {
            return _Fact_Rect || _dtEmpModelos.AsEnumerable().Any(f => Convert.ToBoolean(f["sel"]) && Convert.ToString(f["codigo"]) == tcEmpresa);
        }

        public override bool _Delete()
        {
            bool llExisten = false;
            string lcSql = string.Empty;

            List<string> loTablasTPV = new List<string>()
                {
                    "CAJAS", "D_ALBVEN", "C_ALBVEN", "TIKETS", "VALES", "TAUL_ALB", "COB_REST", "OP_TARJETA", "D_NOTA", "OP_EMV"
                };

            List<string> loTablasGestion = new List<string>()
                {
                    "C_PEDIVE", "D_PEDIVE", "C_ALBVEN", "ALB_FPAG", "C_ALBDEP", "D_ALBDEP", "D_ALBVEN", "EMPRESA", "ENVIOETI", "C_PRESUV", "D_PRESUV",
                    "C_PACKLI", "D_PACKLI", "PORTES", "ENTREGAS", "STOCK_ES", "VENSER", "ALBV_ADI", "PEDV_ADI", "DEPV_ADI", "PRES_ADI", "MULTICA2", "CONTADO", "DEPSER",
                    "ALB_FPA2", "ENTRE_CL", "LOTES", "CUO_ALB", "CONTROL", "ENTRE_PV", "C_CERTIF", "D_CERTIF", "ENTRE_PR", "MODRECTI"
                };

            llExisten = _Existen_Registros("TPV", loTablasTPV, "letra") || _Existen_Registros("GESTION", loTablasGestion, "letra");

            if (!llExisten)
            {
                // Comprobar en rectificativas
                loTablasTPV = new List<string>()
                    {
                        "CAJAS"
                    };

                loTablasGestion = new List<string>()
                    {
                        "EMPRESA"
                    };

                llExisten = _Existen_Registros("TPV", loTablasTPV, "letrarect") || _Existen_Registros("GESTION", loTablasGestion, "letrarect");
            }

            llExisten = !llExisten && ExisteSerieOtrosDocumentos();
            
            if (!llExisten)
            {
                if (base._Delete())
                {
                    //a parte de borrar los registros de la tabla letras, también tenemos que borrar los registros de contador para esta serie en la tabla series                
                    lcSql = "DELETE FROM " + DB.SQLDatabase("SERIES") + " WHERE serie = '" + _Codigo + "'";
                    DB.SQLExec(lcSql);

                    lcSql = "DELETE FROM " + DB.SQLDatabase("GESTION", "MODRECTI") + " WHERE modelo = " + DB.SQLString(_Modelo340) + "  and letra = " + DB.SQLString(_Codigo);
                    DB.SQLExec(lcSql);

                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                _Error_Message = "Este código de Letra está en uso en otras tablas. No se puede borrar la letra.";
                return !llExisten;
            }
        }

        public override void _Load()
        {
            base._Load();

            _ObtenerEmpresasModelo();
        }

        public override void _New(string tcCodigo = "")
        {
            // Antes de seguir comprobar que el código de serie no tenga ningún caracter que no sea una MAYÚSCULA ni NÚMERO          
            if (!contabilidad.CONTABILIDAD._ComprobarFormatoFacturaVenta("", this._Codigo, "", true, true))         
            {
                _Error_Message = "No se permite crear una serie de documento con los caracteres introducidos, solo se permite letras en mayúsculas y/o números.";                
                this.CancelarForm();
                return;
            }

            base._New(tcCodigo);
        }

        public override bool _Save()
        {
            string lcSql = string.Empty;
            DataTable ldtTemp = new DataTable();
            DataTable ldtExiste = new DataTable(); // Bug 107683
            bool llOk = false;
            string[] laEjercicios = null;
            List<string> lstEjerciciosAdd = new List<string>();     // Bug 107683        

            // PARTE 92415. Antes de guardar el registro validamos si existe para posteriormente poder añadir los contadores
            string lcCodigo = DB.SQLValor(this._Tabla, this._Clave, this._Codigo, "CODIGO", this._DataBase).ToString();

            llOk = base._Save();

            if (llOk)
            {
                if (string.IsNullOrWhiteSpace(lcCodigo))
                {
                    // PE-104126. Obtener lista con todos los ejercicios
                    DataTable ldtEjers = new DataTable();
                    string lcSQL = "Select * From " + DB.SQLDatabase("COMUNES", "EJERCICI") + " Order By [any] Asc ";
                    DB.SQLExec(lcSQL, ref ldtEjers);

                    if (ldtEjers != null && ldtEjers.Rows.Count > 0)
                    {
                        int lnEjerDesde = Convert.ToInt16(ldtEjers.Rows[0]["any"]);
                        int lnEjerHasta = Convert.ToInt16(ldtEjers.Rows[ldtEjers.Rows.Count - 1]["any"]);

                        laEjercicios = new string[(lnEjerHasta - lnEjerDesde) + 1];

                        int i = 0;
                        for (int lnEjer = lnEjerDesde; lnEjer <= lnEjerHasta; lnEjer++)
                        {
                            laEjercicios.SetValue(lnEjer.ToString().Trim(), i);
                            i++;
                        }
                    }

                    lcSql = "SELECT serie FROM [multiples_ejercicios].dbo.series WHERE serie = " + DB.SQLString(_Codigo) + " "; // Bug 107683. Montamos la consulta para controlar si existe la serie en los diferentes ejercicios

                    foreach (string lcEjercicio in laEjercicios)
                    {
                        llOk = DB.SQLExecEjer(lcSql, ref ldtExiste, new List<string> { lcEjercicio }.ToArray());

                        if (llOk && ldtExiste != null && ldtExiste.Rows.Count == 0)
                            lstEjerciciosAdd.Add(lcEjercicio);
                    } // FBug 107683

                    //si es un nuevo registro, también hay que guardar en la tabla SERIES el contador a 0 para cada empresa de eurowin y tipodoc de 1 a 8
                    lcSql = "SELECT codigo FROM " + DB.SQLDatabase("EMPRESA");
                    DB.SQLExec(lcSql, ref ldtTemp);

                    foreach (DataRow row in ldtTemp.Rows)
                    {
                        for (int lnI = 1; lnI <= 8; lnI++) //PE-94002: faltaban los tipos 7 y 8
                        {
                            lcSql = "INSERT INTO " + DB.SQLDatabase("", "SERIES") + "(empresa, serie, tipodoc, contador) " +
                                    "VALUES ('" + row["codigo"] + "', '" + _Codigo + "', " + lnI.ToString() + ", 0)";

                            if (lstEjerciciosAdd.Count > 0) // Bug 107683 -  //if (laEjercicios != null && laEjercicios.Length > 0) // PE-104126. Ejecutar insert en todos los ejercicios disponibles
                                llOk = DB.SQLExecEjer(lcSql, lstEjerciciosAdd.ToArray());  // Actualización de los ejercicios donde no tengamos la serie en la tabla de contadores

                            if (!llOk)
                            {
                                // Recollir l'error
                                this._Error_Message = DB.Error_Message;
                            }
                        }
                    }
                }
                SaveSeriesModelo();
            }

            return llOk;
        }

        public bool _ObtenerEmpresasModelo()
        {

            string lcSql = string.Empty;
            DataTable ldtMod = new DataTable();

            // Obtener las empresas del grupo
            _ObtenerEmpresas();

            string lcLetra = !String.IsNullOrWhiteSpace(_Codigo) ?  _Codigo : "!x!";
            lcSql = "SELECT empresa FROM " + DB.SQLDatabase("MODRECTI") + " where modelo = "+ DB.SQLString(_Modelo340) +" and letra = " + DB.SQLString(lcLetra);
            DB.SQLExec(lcSql, ref ldtMod);

            var lstModelos = (from emp in _dtEmpresas.AsEnumerable()
                             join mod in ldtMod.AsEnumerable()
                             on emp.Field<string>("empresa").Trim().ToUpper() equals mod.Field<string>("empresa").Trim().ToUpper() into empDept
                             from ed in empDept.DefaultIfEmpty()
                             select new
                             {
                                 empresa = emp.Field<string>("empresa"),
                                 nombre = emp.Field<string>("nombre"),
                                 sel = (ed == null ? false : true),
                             });

            CrearTable();

            foreach (var mod in lstModelos)
            {
                DataRow loRow = _dtEmpModelos.NewRow();
                loRow["sel"] = mod.sel;
                loRow["codigo"] = mod.empresa;
                loRow["nombre"] = mod.nombre;
                _dtEmpModelos.Rows.Add(loRow);
            }

            return true;
        }

        public bool _SerieRectificativaConfiguradaDefecto(string tcLetra, ref string tcMensaje)
        {
            tcMensaje = "";

            bool llRetorno = serieRectificativaConfiguradaDefecto(ref tcMensaje, tcLetra);

            return llRetorno;
        }

        public bool _SerieRectificativaConfiguradaDefecto(string tcLetra = "")
        {
            string lcMensaje = "";

            return serieRectificativaConfiguradaDefecto(ref lcMensaje, tcLetra);
        }

        private bool serieRectificativaConfiguradaDefecto(ref string tcMensaje, string tcLetra="")
        {
            if (string.IsNullOrWhiteSpace(tcLetra))
                tcLetra = _Codigo;

            if (string.IsNullOrWhiteSpace(tcLetra))
                return false;

            // Mirar si la serie está declarada como rectificativa en alguna empresa.          
            //
            DataTable ldtEmpresas = new DataTable();
            DB.SQLExec("select codigo from " + DB.SQLDatabase("gestion", "empresa") +
                       " where tipo='Normal' and letrarect = " + DB.SQLString(tcLetra) + " and letrarect!=''", ref ldtEmpresas);
            if (ldtEmpresas.Rows.Count > 0)
            {
                tcMensaje = "en alguna empresa."+Environment.NewLine+Environment.NewLine +  
                            "Empresas en las que está declarada la serie rectificativa defecto '"+tcLetra+"': " + Environment.NewLine + Environment.NewLine ;
                foreach (DataRow loRow in ldtEmpresas.Rows)
                {
                    tcMensaje += Convert.ToString(loRow["codigo"])+", ";
                }
                tcMensaje = tcMensaje.Substring(0, tcMensaje.Length - 2);

                FUNCTIONS._DisposeDatatable(ldtEmpresas);

                return true;
            }
            FUNCTIONS._DisposeDatatable(ldtEmpresas);


            // Mirar si la serie está declarada como rectificativa en alguna caja de TPV.           
            //
            if (EW_GLOBAL._ModuloActivo("TPV"))
            {
                DataTable ldtCajas = new DataTable();
                DB.SQLExec("select codigo from " + DB.SQLDatabase("tpv", "cajas") + 
                           " where letrarect = " + DB.SQLString(tcLetra)+" and letrarect!=''", ref ldtCajas);
                if (ldtCajas.Rows.Count > 0)
                {
                    tcMensaje = "en alguna caja TPV." + Environment.NewLine + Environment.NewLine +
                                "Cajas TPV en las que está declarada la serie rectificativa defecto '" + tcLetra + "': " + Environment.NewLine + Environment.NewLine;
                    foreach (DataRow loRow in ldtCajas.Rows)
                    {
                        tcMensaje += Convert.ToString(loRow["codigo"]) + ", ";
                    }
                    tcMensaje = tcMensaje.Substring(0, tcMensaje.Length - 2);

                    FUNCTIONS._DisposeDatatable(ldtCajas);
                    return true;
                }
                FUNCTIONS._DisposeDatatable(ldtCajas);
            }


            // Mirar si la serie está declarada como rectificativa en algún cliente.
            //
            //
            DataTable ldtClientes = new DataTable();
            DB.SQLExec("select codigo from " + DB.SQLDatabase("gestion", "clientes") +
                       " where letdefrect = " + DB.SQLString(tcLetra) + " and letdefrect!=''", ref ldtClientes);
            if (ldtClientes.Rows.Count > 0)
            {
                tcMensaje = "en algún cliente." + Environment.NewLine + Environment.NewLine +
                            "Clientes en los que está declarada la serie rectificativa defecto '" + tcLetra + "': " + Environment.NewLine + Environment.NewLine;
                int lnContador = 0;
                foreach (DataRow loRow in ldtClientes.Rows)
                {
                    tcMensaje += Convert.ToString(loRow["codigo"]) + ", ";
                    lnContador++;
                    if (lnContador > 45)
                        break;
                }
                tcMensaje = tcMensaje.Substring(0, tcMensaje.Length - 2);

                FUNCTIONS._DisposeDatatable(ldtClientes);
                return true;
            }

            FUNCTIONS._DisposeDatatable(ldtClientes);


            // Si tenemos el addon de facturación certificada instalado.
            //
            // Mirar si la serie está declarada como rectificativa en algun cliente en el apartado addons          
            //
            if (EW_GLOBAL._ModuloActivo("FACTUCERT"))
            {
                DataTable ldtClientesAddonFactucert = new DataTable();
                DB.SQLExec("select cliente from " + DB.SQLDatabase("factucert", "fcclientes") +
                           " where letdefrenc = " + DB.SQLString(tcLetra) + " and letdefrenc!=''", ref ldtClientesAddonFactucert);
                if (ldtClientesAddonFactucert.Rows.Count > 0)
                {
                    tcMensaje = "en algún cliente en el apartado Addons - Facturación certificada." + Environment.NewLine + Environment.NewLine +
                                "Clientes en los que está declarada la serie rectificativa no certificable '" + tcLetra + "' en el apartado " +
                                "Addons - Facturación certificada:" + Environment.NewLine + Environment.NewLine;
                    foreach (DataRow loRow in ldtClientesAddonFactucert.Rows)
                    {
                        tcMensaje += Convert.ToString(loRow["cliente"]) + ", ";
                    }
                    tcMensaje = tcMensaje.Substring(0, tcMensaje.Length - 2);

                    FUNCTIONS._DisposeDatatable(ldtClientesAddonFactucert);
                    return true;
                }
                FUNCTIONS._DisposeDatatable(ldtClientesAddonFactucert);
            }

            return false;
        }

        #endregion METODOS PUBLICOS


        #region METODOS PRIVADOS


        private bool existenFacturasConSerie()
        {
            string lcSerie = this._Codigo;
            bool llExisten = false;

            if (string.IsNullOrWhiteSpace(lcSerie))
                return false;

            if (Convert.ToBoolean(global.EW_GLOBAL._GetVariable("wl_serfact")) == true)
            {
                // Mirar en facturas de venta
                DataTable c_factuven = new DataTable();

                string lcSql = "Select EMPRESA, NUMERO " +
                               "From " + DB.SQLDatabase("C_FACTUVEN") + " " +
                               "Where EMPRESA = " + DB.SQLString(global.EW_GLOBAL._GetVariable("wc_empresa")) + " " +
                               "And Left(NUMERO, 2) = " + DB.SQLString(lcSerie);

                if (DB.SQLExec(lcSql, ref c_factuven))
                    llExisten = (c_factuven.Rows.Count > 0);
            }

            return llExisten;

        }

        public bool _ExistenFacturasOperacionREBU()
        {
            string lcSerie = _Codigo;
            bool llExisten = false;
           
            if (string.IsNullOrWhiteSpace(lcSerie))
                return false;

            if (Convert.ToBoolean(global.EW_GLOBAL._GetVariable("wl_serfact")) == true)
            {
                DataTable ldtAuxExisFac = new DataTable();
                StringBuilder lcSql = new StringBuilder();
                
                lcSql.Append($@"
                        Select reper.numfra as factura, reper.asi, 'ivareper' as tipo
                        From {DB.SQLDatabase("ivareper")} reper
                        Inner Join {DB.SQLDatabase("asientos")} asientos On reper.asi = asientos.asi and asientos.operacion = 38
                        Where reper.empresa = {DB.SQLString(_cEmpresa)} and Left(reper.numfra, 2) = {DB.SQLString(lcSerie)} and reper.comunitari = 0 
                        Union all 
                        Select exen.factura, exen.asi, 'iva_exen' as tipo
                        From {DB.SQLDatabase("iva_exen")} exen
                        Inner Join {DB.SQLDatabase("asientos")} asientos On exen.asi = asientos.asi and asientos.operacion = 38
                        Where exen.empresa = {DB.SQLString(_cEmpresa)} and Left(exen.factura, 2) = {DB.SQLString(lcSerie)} and exen.tipo = 2                        
                        ");

                llExisten = (DB.SQLExec(lcSql.ToString(), ref ldtAuxExisFac) && ldtAuxExisFac.Rows.Count > 0);

                FUNCTIONS._DisposeDatatable(ref ldtAuxExisFac);
            }

            return llExisten;

        }

        private void SaveSeriesModelo()
        {
            Int32 lnLinea = 0;
            String lcSql = "";
            StringBuilder loSql = new StringBuilder();
            DataTable loDt = CargarDatos(); 

            lcSql = String.Format("DELETE FROM {0} WHERE modelo = {1} and letra = {2}", DB.SQLDatabase("GESTION", "MODRECTI"), DB.SQLString(_Modelo340), DB.SQLString(this._Codigo));
            if (DB.SQLExec(lcSql))
            {
                List<DataRow> loList = (from loRow in _dtEmpModelos.AsEnumerable()
                                        where Convert.ToBoolean(loRow["sel"])
                                        select loRow).ToList();

                if (loList.Count > 0)
                {
                    foreach (DataRow loRow in loList)
                    {
                        lnLinea = ObtenerLinea(ref loDt, Convert.ToString(loRow["codigo"]));
                        loSql.AppendFormat("INSERT INTO {0} (empresa, modelo, letra, linea) VALUES ({1}, {2}, {3}, {4} );", DB.SQLDatabase("GESTION", "MODRECTI"), DB.SQLString(loRow["codigo"]), DB.SQLString(_Modelo340), DB.SQLString(this._Codigo), lnLinea);
                    }

                    if (!DB.SQLExec(loSql.ToString())) this._Error_Message = DB.Error_Message;
                }

            }
            else
            {
                this._Error_Message = DB.Error_Message;
            }
        }
   
        private Int32 ObtenerLinea(ref DataTable td, String tcCodigoEmpresa)
        {
           
            List<Int32> loList = (from loRow in td.AsEnumerable()
                                  where Convert.ToString(loRow["empresa"]) == tcCodigoEmpresa
                                  select Convert.ToInt32(loRow["linea"])).ToList();
        
            return loList.Count() > 0 ? loList.Max() + 1 : 0;
        }

        private DataTable CargarDatos()
        {
            string lcSql = string.Empty;

            DataTable tdtTempLetra = new DataTable();
            lcSql = "SELECT empresa, letra, linea FROM " + DB.SQLDatabase("GESTION", "MODRECTI") +
                    " where modelo = " + DB.SQLString(_Modelo340) + "";
            DB.SQLExec(lcSql, ref tdtTempLetra);

            return tdtTempLetra;
        }

        private int ObtenerLinea(string tcEmpresa, ref DataTable tdtTempLetra)
        {
            string lcSql = string.Empty;
            int lnLinea = 0;

            if (tdtTempLetra != null && tdtTempLetra.Rows.Count > 0)
            {
                DataRow ldRow = tdtTempLetra.Select("empresa ='" + tcEmpresa + "'").FirstOrDefault();
                if (ldRow != null)
                    lnLinea = Convert.ToInt32(ldRow["linea"]) + 1;
            }

            return lnLinea;
        }

        private bool ExisteSerie(string tcEmpresa, string tcLetra, ref DataTable tdtTempLetra)
        {
            bool llExiste = false;

            if (tdtTempLetra != null && tdtTempLetra.Rows.Count > 0)
                llExiste = tdtTempLetra.Select("empresa ='" + tcEmpresa + "' and letra ='"+ tcLetra+"'").Count() > 0;

            return llExiste;
        }


        private void CrearTable()
        {
            if (_dtEmpModelos == null)
            { 
                _dtEmpModelos = new DataTable();
                _dtEmpModelos.Columns.Add("sel", typeof(bool));
                _dtEmpModelos.Columns.Add("codigo", typeof(string));
                _dtEmpModelos.Columns.Add("nombre", typeof(string));
            }

            _dtEmpModelos.Clear();

        }

        private void _ObtenerEmpresas()
        {
            string lcSql = string.Empty;

            if (_dtEmpresas != null && _dtEmpresas.Rows.Count > 0)
                return;

            _dtEmpresas = new DataTable();
            lcSql = "SELECT codigo as empresa, nombre FROM " + DB.SQLDatabase("EMPRESA")+" order by codigo";
            DB.SQLExec(lcSql, ref _dtEmpresas);
        }

        private bool ExisteSerieOtrosDocumentos()
        {           
            bool llExiste = false;
            DataTable ldtAuxExisConta = new DataTable();
            StringBuilder lcSql = new StringBuilder();

            lcSql.Append($@"
                        Select numero as factura, 'c_factuven ' as tipo
                        From {DB.SQLDatabase("c_factuven")}
                        where Left(numero, 2) = {DB.SQLString(_Codigo)}
                        Union all 
                        Select numfra as factura, 'ivareper' as tipo
                        From {DB.SQLDatabase("ivareper")} 
                        Where Left(numfra,2) = {DB.SQLString(_Codigo)} and comunitari = 0 
                        Union all 
                        Select factura, 'iva_exen' as tipo 
                        From {DB.SQLDatabase("iva_exen")} 
                        Where Left(factura,2) = {DB.SQLString(_Codigo)} and tipo = 2                         
                        Union all 
                        Select numfra as factura, 'retsopor' as tipo 
                        From {DB.SQLDatabase("retsopor")} 
                        Where Left(numfra,2) = {DB.SQLString(_Codigo)}  
                        Union all 
                        Select factura, 'previ_cl' as tipo
                        From {DB.SQLDatabase("comunes", "previ_cl")} 
                        Where Left(factura,2) = {DB.SQLString(_Codigo)}                         
                        ");

            llExiste = (DB.SQLExec(lcSql.ToString(), ref ldtAuxExisConta) && ldtAuxExisConta.Rows.Count > 0);

            FUNCTIONS._DisposeDatatable(ref ldtAuxExisConta);

            return llExiste;
        }
    }

    #endregion
}