AsientoApertura.cs

using sage.ew.contabilidad.Form;
using sage.ew.db;
using sage.ew.empresa;
using sage.ew.ewbase;
using sage.ew.ewbase.Clases;
using sage.ew.formul.Classes;
using sage.ew.functions;
using sage.ew.global;
using sage.ew.interficies;
using sage.ew.listados.Clases;
using sage.ew.listados.Procesos;
using sage.ew.global.Diccionarios;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace sage.ew.contabilidad.Clases
{
    public class AsientoApertura
    {
        private String _cErrorMessage;
        private String _cInfoMessage;
        private Boolean _bGenerarAsientoAplicacionPerdidasGanancias = true;
        private Boolean _bGenerAsientoApertura = true;

        private DateTime? _oDateIni = null;
        private DataTable _oDatosCierre = null;
        private DataTable _oDatosEjercicioAnterior = null;
        private Asientos _oAsientoAntiguo;
        private ProcessBar _oProcess;

        private string _cCuentaResultados = "";
        private string _cCuentaRemanenteAcreedor = "";
        private string _cCuentaRemanenteDeudor = "";

        private string _cNombreCuentaResultados = "";
        private string _cNombreCuentaRemanenteAcreedor = "";
        private string _cNombreCuentaRemanenteDeudor = "";

        private String _cMonedaEmpresa = EW_GLOBAL._Moneda._Codigo;

        
        private enum TipoAsiento
        {
            Apertura,
            Aplicacion
        }

        private String _CuentaResultados
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaResultados)) _cCuentaResultados = Convert.ToString(EW_GLOBAL._GetVariable("wc_perdi"));

                return _cCuentaResultados;
            }
        }

        private String _NombreCuentaResultados
        {
            get
            {
                if(String.IsNullOrEmpty(_cNombreCuentaResultados)) _ObtenerCuentasRemanentes();

                return _cNombreCuentaResultados;
            }
        }

        private String _CuentaRemanenteAcreedor
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaRemanenteAcreedor)) _ObtenerCuentasRemanentes();
                
                return _cCuentaRemanenteAcreedor;
            }
        }

        private String _NombreCuentaRemanenteAcreedor
        {
            get
            {
                if (String.IsNullOrEmpty(_cNombreCuentaRemanenteAcreedor)) _ObtenerCuentasRemanentes();

                return _cNombreCuentaRemanenteAcreedor;
            }
        }

        private String _CuentaRemanenteDeudor
        {
            get
            {
                if (String.IsNullOrEmpty(_cCuentaRemanenteDeudor)) _ObtenerCuentasRemanentes();
              
                return _cCuentaRemanenteDeudor;
            }
        }

        private String _NombreCuentaRemanenteDeudor
        {
            get
            {
                if (String.IsNullOrEmpty(_cNombreCuentaRemanenteDeudor)) _ObtenerCuentasRemanentes();

                return _cNombreCuentaRemanenteDeudor;
            }
        }

        public Boolean _GenerAsientoApertura
        {
            get
            {
                return _bGenerAsientoApertura;
            }
            set
            {
                _bGenerAsientoApertura = value;
            }
        }

        public Boolean _GenerarAsientoAplicacionPerdidasGanancias
        {
            get
            {
                return _bGenerarAsientoAplicacionPerdidasGanancias;
            }
            set
            {
                _bGenerarAsientoAplicacionPerdidasGanancias = value;
            }
        }

        private ProcessBar _ProcessBar
        {
            get
            {
                if (_oProcess == null) _oProcess = new ProcessBar(false, "");
                return _oProcess;
            }
            set
            {
                _oProcess = value;
            }
        }

        private Asientos _AsientoAntiguo
        {
            get
            {
                if (_oAsientoAntiguo == null) _oAsientoAntiguo = new Asientos();
                return _oAsientoAntiguo;
            }
        }

        private String _CodigoEmpresa
        {
            get
            {
                return EW_GLOBAL._Empresa._Codigo;
            }
        }

        public String _ErrorMessage
        {
            get
            {
                return _cErrorMessage;
            }
        }

        public String _InfoMessage
        {
            get
            {
                return _cInfoMessage;
            }
        }
        
        public DateTime _Fecha
        {
            get
            {
                if(_oDateIni == null)
                {
                    _oDateIni =((DateTime)ew.global.EW_GLOBAL._GetVariable("wd_periodoini", DateTime.Today));
                }
                return Convert.ToDateTime(_oDateIni);
            }            
        }

        public Boolean _IsProvisional
        {
            get
            {
                return _DatosCierre.Rows.Count == 0;
            }
        }

        private DataTable _DatosCierre
        {
            get
            {
                if (_oDatosCierre == null)
                {
                    String lcSql, lcCon;

                    _oDatosCierre = new DataTable();

                    if (_ConfigEjercicioAnterior.Rows.Count > 0)
                    {
                        lcCon = DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "ASIENTOS");

                        lcSql = String.Format("SELECT * FROM {0} WHERE EMPRESA = '{1}' AND TIPO = '{2}' ORDER BY CUENTA", lcCon, _CodigoEmpresa, Convert.ToInt32(eTipoMovimientoAsiento.Cierre));
                        DB.SQLExec(lcSql, ref _oDatosCierre);
                    }
                }

                return _oDatosCierre;
            }
        }

        private DataTable _ConfigEjercicioAnterior
        {
            get
            {
                if(_oDatosEjercicioAnterior == null)
                {
                    String lcSql;
                    Int32 lnEjercicio;
                    _oDatosEjercicioAnterior = new DataTable();

                    lnEjercicio = Convert.ToInt32(DB.Ejercicio_EW) - 1;
                    lcSql = String.Format("SELECT * FROM {0} WHERE [ANY] = {1} ", DB.SQLDatabase("COMUNES", "EJERCICI"), DB.SQLString(lnEjercicio));
                    DB.SQLExec(lcSql, ref _oDatosEjercicioAnterior);
                }

                return _oDatosEjercicioAnterior;
            }
        }

        private void _ObtenerCuentasRemanentes()
        {
            String lcSql;
            DataTable loDt = new DataTable();

            lcSql = String.Format("SELECT CODIGO, NOMBRE FROM {0} asi WHERE LEFT(asi.codigo, 3) = '120' OR LEFT(asi.codigo, 3) = '121' OR CODIGO = '{1}' ORDER BY CODIGO ", DB.SQLDatabase("GESTION", "CUENTAS"), _CuentaResultados);
            DB.SQLExec(lcSql, ref loDt);

            if (loDt.Rows.Count > 0)
            {
                List<DataRow> loRows = (from loRow in loDt.AsEnumerable()
                                        where Convert.ToString(loRow["CODIGO"]).Substring(0, 3) == "120"
                                        orderby Convert.ToString(loRow["CODIGO"])
                                        select loRow).ToList();

                if (loRows.Count > 0)
                {
                    _cCuentaRemanenteAcreedor = Convert.ToString(loRows.First()["CODIGO"]);
                    _cNombreCuentaRemanenteAcreedor = Convert.ToString(loRows.First()["NOMBRE"]);
                }

                loRows = (from loRow in loDt.AsEnumerable()
                        where Convert.ToString(loRow["CODIGO"]).Substring(0, 3) == "121"
                        orderby Convert.ToString(loRow["CODIGO"])
                        select loRow).ToList();

                if (loRows.Count > 0)
                {
                    _cCuentaRemanenteDeudor = Convert.ToString(loRows.First()["CODIGO"]);
                    _cNombreCuentaRemanenteDeudor = Convert.ToString(loRows.First()["NOMBRE"]);
                }

                 loRows = (from loRow in loDt.AsEnumerable()
                                        where Convert.ToString(loRow["CODIGO"]) == _CuentaResultados
                                        select loRow).ToList();
                if (loRows.Count > 0)
                {
                    _cNombreCuentaResultados = Convert.ToString(loRows.First()["NOMBRE"]);
                }
            }           
        }

        private String _FiltroFecha(String lcAlias = "")
        {
            String lcSql = "";
            DateTime loPerIniAnt, loPerFinAnt;

            lcAlias = lcAlias.Trim();
            if (!String.IsNullOrEmpty(lcAlias) && !lcAlias.EndsWith(".")) lcAlias = String.Format("{0}.", lcAlias.Trim());

            if (_ConfigEjercicioAnterior.Rows.Count > 0)
            {
                loPerIniAnt = Convert.ToDateTime(_ConfigEjercicioAnterior.Rows[0]["PERIODOINI"]);
                loPerFinAnt = Convert.ToDateTime(_ConfigEjercicioAnterior.Rows[0]["PERIODOFIN"]);

                lcSql = String.Format("AND {0}fecha >= {1} AND {0}fecha <= {2} ", lcAlias, DB.SQLString(loPerIniAnt), DB.SQLString(loPerFinAnt));
            }

            return lcSql;
        }

        public Boolean _AsientoAperturaProvisional(ref Asientos toAsiento)
        {
            return _AsientoAperturaProvisional(ref toAsiento, false);
        }

        public Boolean _AsientoAperturaProvisional(ref Asientos toAsiento, bool tlRenumerar)
        {
            DataTable loDt;

            _cErrorMessage = "";

            _ProcessBar.InitGauge(1, 100, String.Format("Obteniendo datos del ejercicio anterior"));

            loDt = _ObtenerSaldos();

            bool llOk = _CreaAsientoApertura(ref toAsiento, loDt);

            if (llOk && tlRenumerar)
                RenumerarAsientos(2, 0, out string _cErrorMessage);

            return llOk;

        }

        private Boolean _ObtenerAsiento(ref Asientos toAsiento, TipoAsiento totipo)
        {
            Int32 lnNumTipo, lnNum = 0;

            toAsiento._Empresa = _CodigoEmpresa;
            toAsiento._Fecha = _Fecha;

            _oAsientoAntiguo = new Asientos();

            if (totipo == TipoAsiento.Apertura)
            {
                lnNum = _ExisteAsientoApertura();
                lnNumTipo = 1;
                toAsiento._Tipo = "1";
            }
            else
            {
                toAsiento._Tipo = "4";
                lnNum = _ExisteAsientoAplicacion();
                lnNumTipo = 2;
            }

            toAsiento._Numero = lnNum == 0 && !_ExisteNumAsiento(lnNumTipo) ? lnNumTipo : lnNum;

            if (lnNum > 0)
            {
                Asientos loAsientoAper = new Asientos();
                loAsientoAper._Empresa = _CodigoEmpresa;
                loAsientoAper._Numero = lnNum;
                loAsientoAper._Load();
                _oAsientoAntiguo._Clonar(loAsientoAper);

                if (!loAsientoAper._Delete())
                {
                    _cErrorMessage = String.Format("No se ha podido eliminar el asiento {0}", lnNum);
                    return false;
                }
            }

            return true;
        }

        private Boolean _AsientoAplicacionPerdidasGanancias(ref Asientos toAsiento)
        {
            Int32 lnNum;

            _ProcessBar.InitGauge(1, 10, String.Format("Creando asiento de aplicación de pérdidas o ganancias "));

            lnNum = _ExisteAsientoApertura();

            Asientos loAsientoApertura = new Asientos();
            loAsientoApertura._Empresa = _CodigoEmpresa;
            loAsientoApertura._Numero = lnNum;
            loAsientoApertura._Load();

            List<IAsientosLinea> loLinResultados = (from loLin in loAsientoApertura._Lineas
                                                     where loLin._Cuenta == _CuentaResultados
                                                     select loLin).ToList();

            if(loLinResultados.Count > 0)
            {
                if (_ObtenerAsiento(ref toAsiento, TipoAsiento.Aplicacion))
                {
                    if (loLinResultados.First()._Haber != 0 || loLinResultados.First()._Debe != 0)
                    {
                        _ProcessBar.Step();
                                               
                        IAsientosLinea lineaResultados = toAsiento._AddLinea();

                        lineaResultados._Cuenta = _CuentaResultados;
                        lineaResultados._Definicion = _NombreCuentaResultados;

                        IAsientosLinea lineaRemanente = toAsiento._AddLinea();

                        if (loLinResultados.First()._Haber > 0)
                        {
                            lineaResultados._Debe = loLinResultados.First()._Haber;

                            lineaRemanente._Cuenta = _CuentaRemanenteAcreedor;
                            lineaRemanente._Definicion = _NombreCuentaRemanenteAcreedor;
                            lineaRemanente._Haber = lineaResultados._Debe;
                        }
                        else if (loLinResultados.First()._Haber < 0)
                        {
                            lineaResultados._Debe = loLinResultados.First()._Haber;

                            lineaRemanente._Cuenta = _CuentaRemanenteDeudor;
                            lineaRemanente._Definicion = _NombreCuentaRemanenteDeudor;
                            lineaRemanente._Haber = lineaResultados._Debe;
                        }
                        else if (loLinResultados.First()._Debe > 0)
                        {
                            lineaResultados._Debe = loLinResultados.First()._Debe * -1;

                            lineaRemanente._Cuenta = _CuentaRemanenteDeudor;
                            lineaRemanente._Definicion = _NombreCuentaRemanenteDeudor;
                            lineaRemanente._Haber = lineaResultados._Debe;
                        }
                        else if (loLinResultados.First()._Debe < 0)
                        {
                            lineaResultados._Debe = loLinResultados.First()._Debe;

                            lineaRemanente._Cuenta = _CuentaRemanenteDeudor;
                            lineaRemanente._Definicion = _NombreCuentaRemanenteDeudor;
                            lineaRemanente._Haber = lineaResultados._Debe;
                        }

                        if (!toAsiento._Save())
                        {
                            if (_oAsientoAntiguo is Asientos) _oAsientoAntiguo._Save();
                            _cErrorMessage = String.Format("No se ha podido crear el asiento de aplicación: {0}", toAsiento._Mensaje_Error);
                        }
                    }
                    else
                    {
                        _cInfoMessage = "No se ha podido crear el asiento de aplicación ya que el resultado del ejercicio es cero.";
                    }

                    _ProcessBar.InitGauge(10, 10, string.Format("Creando asiento de aplicación de pérdidas o ganancias "));
                }
            }
            else
            {
                _cErrorMessage = string.Format("No se ha podido crear el asiento de aplicación: No se ha encontrado ninguna linea en el asiento de apertura de la cuenta {0}", _CuentaResultados);
            }

            return string.IsNullOrEmpty(_cErrorMessage) && string.IsNullOrEmpty(_cInfoMessage);
        }

        private Boolean _ExisteNumAsiento(Int32 tnNum)
        {
            String lcSql;
            DataTable loDt = new DataTable();

            lcSql = String.Format("SELECT * FROM {0} WHERE EMPRESA = '{1}' AND TIPO != 1 AND TIPO != 4 AND NUMERO = {2} ", DB.SQLDatabase("GESTION", "ASIENTOS"), _CodigoEmpresa, tnNum);
            DB.SQLExec(lcSql, ref loDt);

            return loDt.Rows.Count > 0; 
        }

        private DataTable _ObtenerSaldos()
        {
            DataTable loDtDebe = new DataTable();
            DataTable loDtHaber = new DataTable();
            DataTable loDt = new DataTable();
            String lcCompra, lcVenta, lcSql, lcCon;
            Boolean llNoDivisa;
            DateTime loPerIniAnt, loPerFinAnt;

            lcCompra = Convert.ToString(EW_GLOBAL._GetVariable("wc_compra")).Substring(0, 1); // Primer caracter de la cuenta de compras.
            lcVenta = Convert.ToString(EW_GLOBAL._GetVariable("wc_venta")).Substring(0, 1); // Primer caracter de la cuenta de ventas.

            lcCon = Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]);

            //Asiento agrupado en una sola divisa
            llNoDivisa = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_asicierrediv")); 

            loPerIniAnt = Convert.ToDateTime(_ConfigEjercicioAnterior.Rows[0]["PERIODOINI"]);
            loPerFinAnt = Convert.ToDateTime(_ConfigEjercicioAnterior.Rows[0]["PERIODOFIN"]);


            //Obtinc els saldos dels comptes 
            if(llNoDivisa)
            {
                lcSql = String.Format("SELECT asi.cuenta, cue.nombre, SUM(asi.debe) as debe, SUM(asi.debediv) as debediv, 0.0 as haber, 0.0 as haberDiv, {0} as divisa ", llNoDivisa ? String.Format("'{0}'", EW_GLOBAL._Moneda._Codigo) : "asi.divisa");
            }
            else
            {
                lcSql = String.Format("SELECT asi.cuenta, cue.nombre, asi.debe as debe, asi.debediv as debediv, 0.0 as haber, 0.0 as haberDiv, {0} as divisa, asi.tipo_mov ", llNoDivisa ? String.Format("'{0}'", EW_GLOBAL._Moneda._Codigo) : "asi.divisa");
            }

            lcSql += String.Format("FROM {0} cue LEFT JOIN {1} asi ON cue.codigo = asi.cuenta ", DB.SQLDatabaseReal(lcCon, "CUENTAS"), DB.SQLDatabaseReal(lcCon, "ASIENTOS"));
            lcSql += String.Format("WHERE empresa = '{0}' AND haber = 0  AND tipo != '3' {1}", _CodigoEmpresa, _FiltroFecha("asi"));            
            lcSql += String.Format("AND LEFT(asi.cuenta, 1) != '{0}' AND LEFT(asi.cuenta, 1) != '{1}' ", lcCompra, lcVenta);

            if (llNoDivisa) lcSql += String.Format("GROUP BY asi.cuenta, cue.nombre {0} ", llNoDivisa ? "" : ", asi.divisa");
            lcSql += "ORDER BY asi.CUENTA ";

            if(!DB.SQLExec(lcSql, ref loDtDebe))
            {
                throw new Exception("No se ha podido obtener los saldos de las cuentas. Imposible realizar els asiento de apertura provisional.");
            }

            //Obtinc els saldos dels comptes al DEURE
            if (llNoDivisa)
            {
                lcSql = String.Format("SELECT asi.cuenta, cue.nombre, SUM(asi.haber) as haber, SUM(asi.haberdiv) as haberDiv,  0.0 as debe, 0.0 as debediv, {0} as divisa ", llNoDivisa ? String.Format("'{0}'", _cMonedaEmpresa) : "asi.divisa");
            }
            else
            {
                lcSql = String.Format("SELECT asi.cuenta, cue.nombre, asi.haber as haber, asi.haberdiv as haberDiv,  0.0 as debe, 0.0 as debediv, {0} as divisa, asi.tipo_mov ", llNoDivisa ? String.Format("'{0}'", _cMonedaEmpresa) : "asi.divisa");
            }

            lcSql += String.Format("FROM {0} cue LEFT JOIN {1} asi ON cue.codigo = asi.cuenta ", DB.SQLDatabaseReal(lcCon, "CUENTAS"), DB.SQLDatabaseReal(lcCon, "ASIENTOS"));
            lcSql += String.Format("WHERE empresa = '{0}' AND debe = 0 AND tipo != '3' ", _CodigoEmpresa);
            lcSql += String.Format("AND asi.fecha >= {0} AND asi.fecha <= {1} ", DB.SQLString(loPerIniAnt), DB.SQLString(loPerFinAnt));
            lcSql += String.Format("AND LEFT(asi.cuenta, 1) != '{0}' AND LEFT(asi.cuenta, 1) != '{1}' ", lcCompra, lcVenta);
            if (llNoDivisa) lcSql += String.Format("GROUP BY asi.cuenta, cue.nombre {0} ", llNoDivisa ? "" : ", asi.divisa");
            lcSql += "ORDER BY asi.CUENTA ";

            if (!DB.SQLExec(lcSql, ref loDtHaber))
            {
                throw new Exception("No se ha podido obtener los saldos de las cuentas. Imposible realizar els asiento de apertura provisional.");
            }

            loDt = loDtDebe.Clone();

            _AddRows(ref loDt, loDtDebe);
            _AddRows(ref loDt, loDtHaber);


            if (!llNoDivisa)
            {
                var loGroups = (from loRow in loDt.AsEnumerable()
                                where _EsDiferenciaCambio(Convert.ToInt32(loRow["tipo_mov"]), Convert.ToString(loRow["cuenta"]))
                                group loRow by new { Cuenta = Convert.ToString(loRow["cuenta"]) } into g
                                select new
                                {
                                    Cuenta = g.Key.Cuenta,
                                    Rows = g.ToList().Where(f => Convert.ToString(f["divisa"]) != _cMonedaEmpresa).ToList()
                                }).ToList();


                loGroups.Where(f => f.Rows.Count > 0).ToList().ForEach(f =>
                {
                    var loDiv = (from loRowDiv in loDt.AsEnumerable()
                                 where Convert.ToString(loRowDiv["divisa"]).Trim() != _cMonedaEmpresa && f.Cuenta == Convert.ToString(loRowDiv["cuenta"]).Trim()
                                 select new { Divisa = Convert.ToString(loRowDiv["divisa"]) }).FirstOrDefault();

                    if (loDiv != null)
                    {
                        f.Rows.ForEach(loRow =>
                        {
                            loRow["divisa"] = loDiv.Divisa;
                            loRow["tipo_mov"] = 0;
                            loRow["haberdiv"] = 0;
                            loRow["debediv"] = 0;
                        });
                    }
                });
            }


            loDt = (from loRow in loDt.AsEnumerable()
                    group loRow by new { Cuenta = loRow["CUENTA"], Nombre = loRow["NOMBRE"], Divisa = loRow["DIVISA"] } into g
                    where g.Sum(t => Convert.ToDecimal(t["HABERDIV"])) - g.Sum(t => Convert.ToDecimal(t["DEBEDIV"])) != 0
                    orderby g.Key.Cuenta
                    select new
                    {
                        Cuenta = g.Key.Cuenta,
                        Nombre = g.Key.Nombre,
                        Divisa = g.Key.Divisa,
                        Debe = g.Sum(t => Convert.ToDecimal(t["DEBE"])),
                        Haber = g.Sum(t => Convert.ToDecimal(t["HABER"])),
                        DebeDiv = g.Sum(t => Convert.ToDecimal(t["DEBEDIV"])),
                        HaberDiv = g.Sum(t => Convert.ToDecimal(t["HABERDIV"])),
                        ImporteDiv = 0,
                        Cambio = 0.0
                    }).__CopyToDataTable();


            _TratarMonedaEmpresa(loDt);

            for (Int32 lnI = 0; lnI < loDt.Rows.Count; lnI++)
            {
                DataRow loRowTmp = loDt.Rows[lnI];

                _TrataLinea(ref loRowTmp);
            }

            //Añadimos la linea de perdidas y ganancias
            DataRow loRowPerdidadGanancias = loDt.NewRow();
            loRowPerdidadGanancias["CUENTA"] = _CuentaResultados;
            loRowPerdidadGanancias["NOMBRE"] = _NombreCuentaResultados;
            loRowPerdidadGanancias["DIVISA"] = _cMonedaEmpresa;
            loRowPerdidadGanancias["DEBE"] =  loDt.AsEnumerable().Sum(f=>Convert.ToDecimal(f["DEBE"]));
            loRowPerdidadGanancias["HABER"] = loDt.AsEnumerable().Sum(f => Convert.ToDecimal(f["HABER"]));
            loRowPerdidadGanancias["DEBEDIV"] = loDt.AsEnumerable().Sum(f => Convert.ToDecimal(f["DEBEDIV"]));
            loRowPerdidadGanancias["HABERDIV"] = loDt.AsEnumerable().Sum(f => Convert.ToDecimal(f["HABERDIV"]));

            _TrataLinea(ref loRowPerdidadGanancias);
            loDt.Rows.Add(loRowPerdidadGanancias);

            loDt = (from loRow in loDt.AsEnumerable()
                    where Convert.ToDecimal(loRow["DEBE"]) + Convert.ToDecimal(loRow["HABER"]) != 0
                    orderby loRow["CUENTA"]
                    select loRow).__CopyToDataTable();

            return loDt;
        }

        private void _AddRows(ref DataTable loDtTo, DataTable loDtFrom)
        {
            foreach (DataRow loRow in loDtFrom.Rows)
            {
                loDtTo.ImportRow(loRow);
            }
        }

        private bool _EsDiferenciaCambio(int tnTipoMov, string tcCuenta)
        {
            AsientoTipoMov toTipoMov;

            if (Enum.IsDefined(typeof(AsientoTipoMov), tnTipoMov))
            {
                toTipoMov = (AsientoTipoMov)tnTipoMov;

                switch (toTipoMov)
                {
                    case AsientoTipoMov.DiferenciasCambioCobro:
                    case AsientoTipoMov.DiferenciasCambioCierreCobro:
                        return CONTABILIDAD._EsCliente(tcCuenta);
                    case AsientoTipoMov.DiferenciasCambioPago:
                    case AsientoTipoMov.DiferenciasCambioCierrePago:
                        return CONTABILIDAD._EsProveedor(tcCuenta);
                    case AsientoTipoMov.DiferenciasCambioBancoCaja:
                    case AsientoTipoMov.DiferenciasCambioBancoCajaCierre:
                        return _EsBanco(tcCuenta);
                }
            }
            return false;

        }

        private void _TratarMonedaEmpresa(DataTable dtDatos)
        {
 
            var loGroups = (from loRow in dtDatos.AsEnumerable()
                            group loRow by new { Cuenta = Convert.ToString(loRow["cuenta"]) } into g
                            where !CONTABILIDAD._EsCliente(g.Key.Cuenta) && !CONTABILIDAD._EsProveedor(g.Key.Cuenta) && !_EsBanco(g.Key.Cuenta)
                            select new
                            {
                                Cuenta = g.Key.Cuenta,
                                Rows = g.ToList().Where(f => Convert.ToString(f["divisa"]) != _cMonedaEmpresa).ToList()
                            });

            loGroups.Where(f => f.Rows.Count > 0).ToList().ForEach(f => f.Rows.ForEach(loRow =>
            {
                loRow["divisa"] = _cMonedaEmpresa;
                loRow["debediv"] = loRow["debe"];
                loRow["haberdiv"] = loRow["haber"];
            }));
        }

        private bool _EsBanco(string tcCuenta)
        {
            return tcCuenta.Length > 2 ? CONTABILIDAD._EsBancoCajaDivisa(tcCuenta.Substring(0, 3)) : false;
        }

        private void _TrataLinea(ref DataRow loRow)
        {
            Decimal lnDebe, lnHaber, lnDebeDiv, lnHaverDiv, lnCambio;

            lnDebe = Convert.ToDecimal(loRow["DEBE"]);
            lnHaber = Convert.ToDecimal(loRow["HABER"]);
            lnDebeDiv = Convert.ToDecimal(loRow["DEBEDIV"]);
            lnHaverDiv = Convert.ToDecimal(loRow["HABERDIV"]);
            lnCambio = 1;

            if (lnDebe > lnHaber)
            {
                loRow["DEBE"] = loRow["DEBEDIV"] = 0;
                loRow["HABER"] = lnDebe - lnHaber;

                if (Convert.ToString(loRow["DIVISA"]) == _cMonedaEmpresa)
                {
                    loRow["HABERDIV"] = loRow["HABER"];
                }
                else
                {
                    loRow["HABERDIV"] = lnDebeDiv - lnHaverDiv;
                    lnCambio = Convert.ToDecimal(loRow["HABERDIV"]) == 0 ? 1 : Convert.ToDecimal(loRow["HABER"]) / Convert.ToDecimal(loRow["HABERDIV"]);
                    
                }
                loRow["CAMBIO"] = lnCambio;
            }
            else if (lnHaber > lnDebe)
            {
                loRow["DEBE"] = lnHaber - lnDebe;
                loRow["HABERDIV"] = loRow["HABER"] = 0;
                    
                if (Convert.ToString(loRow["DIVISA"]) ==_cMonedaEmpresa)
                {
                    loRow["DEBEDIV"] = loRow["DEBE"];
                }
                else
                {
                    loRow["DEBEDIV"] = lnHaverDiv - lnDebeDiv;
                    lnCambio = Convert.ToDecimal(loRow["DEBEDIV"]) == 0 ? 1 : Convert.ToDecimal(loRow["DEBE"]) / Convert.ToDecimal(loRow["DEBEDIV"]);
                }                    
            }
            else
            {
                loRow["DEBE"] = 0;
                loRow["HABER"] = 0;
            }
   
            loRow["CAMBIO"] = lnCambio;
        }

        public Boolean _AsientoApertura(ref Asientos toAsiento)
        {
            return _CreaAsientoApertura(ref toAsiento, _DatosCierre);
        }

        public ResultadoOperacion CrearAsientoApertura(string ejercicio, List<AsientoCierreRegularizacion.SaldoCierre> lineasParaApertura)
        {

            List<String> loMesesCerrados = new List<String>();

            try
            {        
                //Comprobaciones iniciales
                if (string.IsNullOrWhiteSpace(ejercicio))
                    return new ResultadoOperacion(false, "No se ha especificado ejercicio.");

                if (lineasParaApertura == null || lineasParaApertura.Count() == 0)
                    return new ResultadoOperacion(false, "No se han especificado lineas para el asiento de apertura.");

                //Empezamos la ejecución

                //1.- Borrar apertura preexistente 
                bool hayAperturaPrevia = Asientos.ContieneAsientoApertura(ejercicio) == true;
                bool aperturaCorrecta = true;
                bool aplicacionCorrecta = true;

                string mensajeEjecucion = "Proceso realizado con éxito";

                //Abro los meses para operar
                loMesesCerrados = MesesCerrados.ObtenerMesesCerrados();
                MesesCerrados.AbrirTodos();

                //2.- Crear el asiento con las líneas recibidas
                Asientos asientoApertura = new Asientos();
                Asientos asientoAplicacion = new Asientos();

                List<AsientoCierreGenerado> asientosGenerados = new List<AsientoCierreGenerado>();

                Int32 lnNumApertura = _ExisteAsientoApertura();
                Int32 lnNumAplicacion = _ExisteAsientoAplicacion();

                Boolean lRenumerar = (lnNumApertura == 0 || lnNumAplicacion == 0);

                if (_ObtenerAsiento(ref asientoApertura, TipoAsiento.Apertura))
                {
                    foreach (var lineaSaldo in lineasParaApertura)
                    {
                        IAsientosLinea loLin = asientoApertura._AddLinea();
                        lineaSaldo.InvertirDebeHaber().ToAsientosLinea(loLin);
                        loLin._Definicion = "ASIENTO APERTURA";
                    }

                    if (hayAperturaPrevia)
                    {
                        if (!Asientos.DeleteAsientoApertura(ejercicio))
                        {
                            return new ResultadoOperacion(false, "No se ha podido borrar el asiento de apertura previo.");
                        }
                    }

                    if (aperturaCorrecta = asientoApertura._Save())
                    {
                        if (aplicacionCorrecta = _AsientoAplicacionPerdidasGanancias(ref asientoAplicacion))
                        {
                            if (lRenumerar)
                            {
                                if (RenumerarAsientos(asientoApertura._Numero, asientoAplicacion._Numero, out string errorRenumeracion))
                                {
                                    asientoApertura._Numero = 1;
                                    asientoAplicacion._Numero = 2;
                                }
                                else
                                {
                                    //Un fallo en la renumeración no lo consideramos suficientemente grave para retroceder el proceso pero propago su mensaje
                                    mensajeEjecucion = errorRenumeracion;
                                }
                            }
                        }
                        else
                        {
                            mensajeEjecucion = asientoAplicacion._Mensaje_Error;
                        }
                    }
                    else
                    {
                        mensajeEjecucion = asientoApertura._Mensaje_Error;
                       
                    }

                    if (aperturaCorrecta)
                    {
                        //Creo información de retorno
                        AsientoCierreGenerado asientoGenerado = new AsientoCierreGenerado(asientoApertura, ejercicio)
                        {
                            Categoria = "Asiento de apertura",
                            Descripcion = "Asiento de apertura"
                        };
                        asientosGenerados.Add(asientoGenerado);
                    }

                    if(aplicacionCorrecta)
                    {
                        //Creo información de retorno
                        AsientoCierreGenerado asientoGenerado = new AsientoCierreGenerado(asientoAplicacion, ejercicio)
                        {
                            Categoria = "Asiento de apertura",
                            Descripcion = "Asiento de aplicación de pérdidas o ganancias"
                        };
                        asientosGenerados.Add(asientoGenerado);
                    }
                }

                var resultado = new ResultadoOperacion(aperturaCorrecta, mensajeEjecucion)
                {
                    Datos = asientosGenerados
                };

                return resultado;
            }
            finally
            {
                MesesCerrados.Cerrar(loMesesCerrados);
            }
        }

        private bool _CreaAsientoApertura(ref Asientos toAsiento, DataTable toDatos)
        {
            if (toDatos is DataTable && toDatos.Rows.Count > 0)
            {
                _cErrorMessage = "";

                _ProcessBar.InitGauge(1, 100, String.Format("Creación automática del asiento de apertura"));

                if (_ObtenerAsiento(ref toAsiento, TipoAsiento.Apertura))
                {
                    _ProcessBar.InitGauge(1, toDatos.Rows.Count + 1, String.Format("Creando lineas del asiento apertura "));

                    foreach (DataRow loRow in toDatos.Rows)
                    {
                        IAsientosLinea loLin = toAsiento._AddLinea();

                        loLin._Cuenta = Convert.ToString(loRow["CUENTA"]);
                        loLin._Definicion = "ASIENTO DE APERTURA";
                        loLin._Divisa = Convert.ToString(loRow["DIVISA"]);
                        loLin._Cambio = Convert.ToDecimal(loRow["CAMBIO"]);
                        loLin._Debe = Convert.ToDecimal(loRow["HABER"]);
                        loLin._DebeDiv = Convert.ToDecimal(loRow["HABERDIV"]);
                        loLin._Haber = Convert.ToDecimal(loRow["DEBE"]);
                        loLin._HaberDiv = Convert.ToDecimal(loRow["DEBEDIV"]);
                       
                        _ProcessBar.Step(String.Format("Apertura de la cuenta {0} ", loLin._Cuenta));
                    }

                    _ProcessBar.Step(String.Format("Guardando asiento apertura ", toAsiento._Numero));

                    if (!toAsiento._Save())
                    {
                        if (_oAsientoAntiguo is Asientos) _oAsientoAntiguo._Save();
                        _cErrorMessage = String.Format("No se ha podido crear el asiento de apertura: {0}", toAsiento._Mensaje_Error);
                    }
                }
            }
            else
            {
                _cErrorMessage = "No hay datos para generar el asiento de apertura";
            }

            return String.IsNullOrEmpty(_cErrorMessage);
        }

        public void _Generar(ProcessBar _oProcess = null)
        {
           
            Boolean  lOk = true;
            Boolean lRenumerar = true;
            Asientos loAsientosApertura = new Asientos();
            Asientos loAsientosAplicacion = new Asientos();
            List<Asientos> loList = new List<Asientos>();
            List<String> loMesesCerrados = new List<String>();
            Int32 lnNumApertura, lnNumAplicacion;

            //Abro los meses para operar
            loMesesCerrados = MesesCerrados.ObtenerMesesCerrados();
            MesesCerrados.AbrirTodos();

            _cInfoMessage = "";
            _ProcessBar = _oProcess;

            try
            {
                lnNumApertura = _ExisteAsientoApertura();
                lnNumAplicacion = _ExisteAsientoAplicacion();

                lRenumerar = (lnNumApertura == 0 || lnNumAplicacion == 0);

                if (_GenerAsientoApertura)
                {
                    if (_IsProvisional)
                    {
                        lOk = _AsientoAperturaProvisional(ref loAsientosApertura);
                    }
                    else
                    {
                        lOk = _AsientoApertura(ref loAsientosApertura);
                    }

                    if (lOk) loList.Add(loAsientosApertura);
                }

                if (_GenerarAsientoAplicacionPerdidasGanancias && lOk)
                {
                    lOk = _AsientoAplicacionPerdidasGanancias(ref loAsientosAplicacion);
                    if (lOk) loList.Add(loAsientosAplicacion);
                }

                if (loList.Count > 0)
                {
                    _ProcessBar._Result = loList;

                    //Proceso de renumeración            
                    if (lRenumerar && (loAsientosApertura._Numero > 1 || loAsientosAplicacion._Numero > 2))
                    {
                        _ProcessBar.InitGauge(1, 3, String.Format("Ejecutado proceso de renumeración"));

                        if (RenumerarAsientos(loAsientosApertura._Numero, loAsientosAplicacion._Numero, out string mensaje))
                        {
                            loAsientosApertura._Numero = 1;
                            loAsientosAplicacion._Numero = 2;

                            _ProcessBar.Step();
                        }
                        else
                        {
                            _cInfoMessage = mensaje;
                        }
                        _ProcessBar.Step();
                    }
                }
            }            
            finally
            {
                //Dejo como estaban los meses
                MesesCerrados.Cerrar(loMesesCerrados);
            }                       
        }    
        
        private bool RenumerarAsientos(int numeroAsientoApertura, int numeroAsientoAplicacion, out string mensaje)
        {
            mensaje = string.Empty;
            if (numeroAsientoApertura > 1 || numeroAsientoAplicacion > 2) //Si hace falta renumerar
            {
                _ProcessBar.Step();

                RenumeracionAsientos loProcess = new RenumeracionAsientos();

                if (!loProcess._Execute_Process())
                {
                    //Detallo la numeración de los asientos en caso de error

                    string soloApertura =   $"El asiento de apertura se ha creado con el número {numeroAsientoApertura}";
                    string soloAplicacion = $"El asiento de aplicación se ha creado con el número {numeroAsientoAplicacion}";
                    string ambosAsientos =  $"El asiento de apertura se ha creado con el número {numeroAsientoApertura} y el asiento de aplicación se ha creado con el número {numeroAsientoAplicacion}";

                    mensaje = _GenerAsientoApertura ? (_GenerarAsientoAplicacionPerdidasGanancias ? ambosAsientos : soloApertura) : soloAplicacion;

                    mensaje = $"{mensaje}, ya que no se ha podido ejecutar el proceso de renumeración.{Environment.NewLine}({loProcess._Error_Message}) ";

                    return false;
                }
            }

            return true;
        }


        public void _Show()
        {
            frmAsientoApertura loForm = new frmAsientoApertura(this);
            loForm._ShowDialog();            
        }

        public bool _Valida()
        {
            Int32 lnResult = 0;
            Boolean lOk = true;
            DataTable loDtCuentas;

            _cErrorMessage = "";

            if (((Empresa)EW_GLOBAL._Empresa)._EsConsolidada)
            {
                _cErrorMessage = " en empresas consolidadas.";
            }
            //else if (_MesCerrado(_Fecha))
            //{
            //    _cErrorMessage = ". El mes de la fecha inicial del periodo esta cerrado.";
            //}
            else if (!_ExisteEjercicioAnterior())
            {
                _cErrorMessage = ". No existe ningún ejercicio anterior del que recuperar los datos.";
            }
            else if (_GenerAsientoApertura && _IsProvisional && (lnResult = _AsientosDescuadrados()) > 0)
            {
                _cErrorMessage = lnResult > 1 ? String.Format(". Se han localizado {0} asientos descuadrados", lnResult) : ". Se ha localizado 1 asiento descuadrado";
                _cErrorMessage = String.Format("{0} en el ejercicio anterior. Imposible realizar el asiento de apertura provisional.{1}Utilice la opción de revisión de asientos en el ejercicio anterior para comprobar los posibles errores. ", _cErrorMessage, Environment.NewLine);
            }
            else if (!_GenerAsientoApertura && _GenerarAsientoAplicacionPerdidasGanancias && _ExisteAsientoApertura() == 0)
            {
                _cErrorMessage = " porque no existe asiento de apertura";
            }

            if (String.IsNullOrEmpty(_cErrorMessage))
            {
                loDtCuentas = _ValidarCuentasPorEjercicio();

                if (_GenerAsientoApertura && loDtCuentas.Rows.Count > 0)
                {
                    List<String> loCuentas = (from loRow in loDtCuentas.AsEnumerable()
                                              select Convert.ToString(loRow["CODIGO"]).Trim()).Distinct().ToList();

                    _cErrorMessage = String.Format(" porque hay cuentas del ejercicio {0} ({2}) necesarias para la apertura que no existen en el ejercicio {1}.{3}{3}Antes de crear la apertura debe traspasar dichas cuentas en el ejercicio {1}.", Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["ANY"]).Trim(), DB.Ejercicio_EW, string.Join(", ", loCuentas), Environment.NewLine);
                }
            }

            if (String.IsNullOrEmpty(_cErrorMessage))
            {
                loDtCuentas = _ValidarLongitudCuentas();

                if (_GenerAsientoApertura && loDtCuentas.Rows.Count > 0)
                {
                    List<String> loCuentas = (from loRow in loDtCuentas.AsEnumerable()
                                              select Convert.ToString(loRow["CODIGO"]).Trim()).Distinct().ToList();

                    _cErrorMessage = String.Format(" porque hay cuentas del ejercicio {0} ({2}) necesarias para la apertura que no tienen la longitud correcta.{3}{3}Antes de crear la apertura debe revisar las cuentas en el ejercicio {0}.", Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["ANY"]).Trim(), DB.Ejercicio_EW, string.Join(", ", loCuentas), Environment.NewLine);
                }
            }

            if (String.IsNullOrEmpty(_cErrorMessage))
            {
                lOk = _ValidarCuentasAplicacion();
                lOk = lOk && _ExistenAsientosAperturaAplicacion();
            }


            if (!String.IsNullOrEmpty(_cErrorMessage))
            {
                String lcCadenaAsientos;

                if(_GenerarAsientoAplicacionPerdidasGanancias && _GenerAsientoApertura)
                {
                    lcCadenaAsientos = String.Format("No se puede crear el asiento de apertura {0} ni el asiento de aplicación de pérdidas o ganancias", _IsProvisional ? "provisional" : "definitivo"); 
                }
                else if (_GenerAsientoApertura)
                {
                    lcCadenaAsientos = String.Format("No se puede crear el asiento de apertura {0}", _IsProvisional ? "provisional" : "definitivo");
                }
                else
                {
                    lcCadenaAsientos = "No se puede crear el asiento de aplicación de pérdidas o ganancias";
                }
                _cErrorMessage = String.Format("{0}{1}", lcCadenaAsientos, _cErrorMessage);
            }
            
            lOk &= String.IsNullOrEmpty(_cErrorMessage);

            return lOk;
        }

        private DataTable _ValidarLongitudCuentas()
        {

            String lcSql;
            DataTable loDt = new DataTable();
            Int32 lnLen = EW_GLOBAL._GetLenCampo(KeyDiccionarioLenCampos.wn_digitos);

            if (_IsProvisional)
            {
                lcSql = String.Format("SELECT CODIGO FROM {0} INNER JOIN ", DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "CUENTAS"));
                lcSql += String.Format("(SELECT CUENTA FROM {0} asi WHERE EMPRESA = {1} {2}  GROUP BY CUENTA HAVING SUM(asi.debediv) - SUM(asi.haberDiv) <> 0) e ON e.CUENTA = CODIGO ", DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "ASIENTOS"), DB.SQLString(_CodigoEmpresa), _FiltroFecha("asi"));
                lcSql += String.Format("WHERE LEN(CODIGO) <> {0} ", lnLen);
            }
            else
            {
                lcSql = String.Format("SELECT CODIGO FROM {0} INNER JOIN ", DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "CUENTAS"));
                lcSql += String.Format("(SELECT CUENTA FROM {0} asi WHERE EMPRESA = {1} AND TIPO = '{2}' ) e ON e.CUENTA = CODIGO  ", DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "ASIENTOS"), DB.SQLString(_CodigoEmpresa), Convert.ToInt32(eTipoMovimientoAsiento.Cierre));
                lcSql += String.Format("WHERE LEN(CODIGO) <> {0} ", lnLen);
            }
            DB.SQLExec(lcSql, ref loDt);

            return loDt;

        }


        private DataTable _ValidarCuentasPorEjercicio()
        {
            String lcSql;
            DataTable loDt = new DataTable();

            if (_ConfigEjercicioAnterior.Rows.Count > 0)
            {
                if (_IsProvisional)
                {
                    lcSql = String.Format("SELECT CODIGO FROM {0} INNER JOIN ", DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "CUENTAS"));
                    lcSql += String.Format("(SELECT CUENTA FROM {0} asi WHERE EMPRESA = {1} {2}  GROUP BY CUENTA HAVING SUM(asi.debediv) - SUM(asi.haberDiv) <> 0) e ON e.CUENTA = CODIGO ", DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "ASIENTOS"), DB.SQLString(_CodigoEmpresa), _FiltroFecha("asi"));
                    lcSql += String.Format("WHERE CUENTA NOT IN (SELECT CODIGO FROM {0})", DB.SQLDatabase("GESTION", "CUENTAS"));
                }
                else
                {
                    lcSql = String.Format("SELECT CODIGO FROM {0} INNER JOIN ", DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "CUENTAS"));
                    lcSql += String.Format("(SELECT CUENTA FROM {0} asi WHERE EMPRESA = {1} AND TIPO = '{2}' ) e ON e.CUENTA = CODIGO  ", DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "ASIENTOS"), DB.SQLString(_CodigoEmpresa), Convert.ToInt32(eTipoMovimientoAsiento.Cierre));
                    lcSql += String.Format("WHERE CUENTA NOT IN (SELECT CODIGO FROM {0})", DB.SQLDatabase("GESTION", "CUENTAS"));
                }
                DB.SQLExec(lcSql, ref loDt);
            }

            return loDt;
        }

        private bool _ValidarCuentasAplicacion()
        {
            if (_GenerarAsientoAplicacionPerdidasGanancias && (String.IsNullOrEmpty(_CuentaRemanenteAcreedor) || (String.IsNullOrEmpty(_CuentaRemanenteDeudor))))
            {
                String lcErrorMessage;

                if (String.IsNullOrEmpty(_CuentaRemanenteAcreedor) && (String.IsNullOrEmpty(_CuentaRemanenteDeudor)))
                {
                    lcErrorMessage = " porque no existe la cuenta (120 - Remanente) ni la cuenta (121 - Resultados negativos de ejercicios anteriores).";
                }
                else
                {
                    lcErrorMessage = String.Format(" porque no existe la cuenta {0}. ", String.IsNullOrEmpty(_CuentaRemanenteAcreedor) ? "(120 - Remanente)" : " (121 - Resultados negativos de ejercicios anteriores)");
                }

                if (_GenerAsientoApertura)
                {
                    lcErrorMessage = String.Format("No se puede generar el asiento de aplicación de pérdidas o ganancias {0}{1}{1}¿Desea continuar y generar el asiento de apertura {2}? ", lcErrorMessage, Environment.NewLine, _IsProvisional ? "provisional" : "definitivo");
                    
                    if (DialogResult.Yes == FUNCTIONS._MessageBox(lcErrorMessage, "Validación cuentas", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2))
                    {
                        _GenerarAsientoAplicacionPerdidasGanancias = false;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    _cErrorMessage = lcErrorMessage;
                    return false;
                }
            }

            return true;
        }

        private Boolean _ExistenAsientosAperturaAplicacion()
        {
            Int32 lnResultAper = 0, lnResultApli = 0;
            String lcErrorMessage, lcTitulo;
            Boolean lbApertura = false, lbAplicacion = false;

            lbApertura = _GenerAsientoApertura && (lnResultAper = _ExisteAsientoApertura()) > 0;
            lbAplicacion = _GenerarAsientoAplicacionPerdidasGanancias && (lnResultApli = _ExisteAsientoAplicacion()) > 0;

            if (lbApertura || lbAplicacion)
            {
                if (lbApertura && lbAplicacion)
                {
                    lcTitulo = "No se pueden crear los asientos";
                    lcErrorMessage = String.Format("Ya existen los asientos de apertura con número {0} y de aplicación de pérdidas o ganancias con número {1} en el ejercicio actual.{2}{2}Si continua con el proceso se eliminarán los asientos existentes y se crearán de nuevo.{1}{1}¿Desea continuar? ", lnResultAper, lnResultApli, Environment.NewLine);
                }
                else if (!lbApertura && lbAplicacion)
                {
                    lcTitulo = "No se puede crear el asiento de aplicación de pérdidas o ganancias";
                    lcErrorMessage = String.Format("Ya existe un asiento de aplicación de pérdidas o ganancias con número {0} en el ejercicio actual.{1}{1}Si continua con el proceso se eliminará el asiento de aplicación de pérdidas o ganancias existente y se creará de nuevo.{1}{1}¿Desea continuar? ", lnResultApli, Environment.NewLine);
                }
                else
                {
                    lcTitulo = "No se puede crear el asiento de apertura";
                    lcErrorMessage = String.Format("Ya existe un asiento de apertura con número {0} en el ejercicio actual.{1}{1}Si continua con el proceso se eliminará el asiento de apertura existente y se creará de nuevo.{1}{1}¿Desea continuar? ", lnResultAper, Environment.NewLine);
                }

                if (DialogResult.No == FUNCTIONS._MessageBox(lcErrorMessage, lcTitulo, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2))
                {
                    return false;
                }
            }
            return true;
        }

        private Int32 _ExisteAsientoApertura()
        {
            return _ExisteAsiento("AND TIPO = 1");
        }

        private Int32 _ExisteAsientoAplicacion()
        {
            return _ExisteAsiento("AND TIPO = 4");
        }

        private Int32 _ExisteAsiento(String tcCond)
        {
            Int32 lnNum = 0;
            String lcSql;
            DataTable loDt = new DataTable();

            lcSql = String.Format("SELECT NUMERO FROM {0} WHERE EMPRESA = '{1}' {2}  ", DB.SQLDatabase("GESTION", "ASIENTOS"), _CodigoEmpresa, tcCond);
            DB.SQLExec(lcSql, ref loDt);

            if (loDt.Rows.Count > 0) lnNum = Convert.ToInt32(loDt.Rows[0]["numero"]);
                
             return lnNum;
        }

        private Int32 _AsientosDescuadrados()
        {
            String lcSql, lcCon;
            DataTable loDt = new DataTable();

            if (_ConfigEjercicioAnterior.Rows.Count > 0)
            {
                lcCon = DB.SQLDatabaseReal(Convert.ToString(_ConfigEjercicioAnterior.Rows[0]["CONEXION"]), "ASIENTOS");

                lcSql = String.Format("SELECT numero, SUM(debe - haber) as saldo FROM {0} WHERE EMPRESA = '{1}' {3} GROUP BY numero HAVING ROUND(SUM(debe - haber), {2}) != 0" , lcCon, _CodigoEmpresa, EW_GLOBAL._GetVariable("wn_Decimales"), _FiltroFecha());

                DB.SQLExec(lcSql, ref loDt);
            }

            return loDt.Rows.Count;
        }

        private bool _ExisteEjercicioAnterior()
        {
            return _ConfigEjercicioAnterior.Rows.Count > 0;                
        }

        private bool _MesCerrado(DateTime? toFecha)
        {
            String lcSql;
            DataTable loDt = new DataTable();

            lcSql = String.Format("SELECT * FROM {0} WHERE EMPRESA = '{1}' AND CERRADO = {2} AND CODIGO = {3}", DB.SQLDatabase("GESTION", "MESES"), _CodigoEmpresa, DB.SQLTrue(), toFecha?.Month);
            DB.SQLExec(lcSql, ref loDt);

            return loDt.Rows.Count > 0;
        }
    }
}