PagarePago.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Data;
using System.Windows.Forms;
using sage.ew.ewbase;
using sage.ew.functions;
using sage.ew.db;
using sage.ew.global;
using sage.ew.contabilidad;
using sage.ew.global.Diccionarios;
using sage.ew.interficies;
using sage.ew.formul.Forms;
using sage.ew.reports;
using System.IO;
using sage.ew.usuario;
using sage.ew.docscompra.UserControls;
using sage.ew.netvfp;
using sage.ew.empresa;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static sage.ew.contabilidad.Cuenta;

namespace sage.ew.docscompra
{
    public class PagarePago : ewMante, IDocumentoImprimible
    {
        #region PROPIEDADES PRIVADAS


        private string _lcAny = Convert.ToString(EW_GLOBAL._GetVariable("wc_any"));


        private string _cMonedaEmpresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda"));


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


        private bool _lEmpresaNormal = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_normal"));


        private bool _lEjerPartido = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_parti"));


        private DateTime _dPeriodoIni = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));


        private DateTime _dPeriodoFin = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodofin"));


        private bool _lEfectoPag = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_efectopag"));


        private string _cEfecProv = Convert.ToString(EW_GLOBAL._GetVariable("wc_efec_pro"));


        private string _cEfecAcre = Convert.ToString(EW_GLOBAL._GetVariable("wc_efec_acre"));


        private string _cProveedor = Convert.ToString(EW_GLOBAL._GetVariable("wc_proveed"));


        private string _cAcreedor = Convert.ToString(EW_GLOBAL._GetVariable("wc_acreed"));


        private int _nDigitos = Convert.ToInt32(EW_GLOBAL._GetLenCampo(KeyDiccionarioLenCampos.wn_digitos));

        #endregion PROPIEDADES PRIVADAS


        #region PROPIEDADES PUBLICAS

        [DefaultValue("")]
        public string _Empresa
        {
            get { return Convert.ToString(_Campo("EMPRESA")); }
            set { _Campo("EMPRESA", value); }
        }


        [DefaultValue("")]
        public string _Banco
        {
            get
            {
                return Convert.ToString(_Campo("BANCO"));
            }
            set
            {

                if (string.IsNullOrWhiteSpace(this._Empresa))
                    this._Empresa = this._cEmpresa;

                _Campo("BANCO", value);
            }
        }


        [DefaultValue("")]
        public string _Pagare
        {
            get {
                // Añado espacios a la derecha por que lo trae alltrimeado a menudo, y es un campo que está formateado con el valor a la izquierda y
                // espacios a la derecha.
                //
                return Convert.ToString(_Campo("PAGARE")).PadRight(10, ' ');
            }
            set {

                if (string.IsNullOrWhiteSpace(this._Empresa))
                    this._Empresa = this._cEmpresa;

                _Campo("PAGARE", value);
            }
        }


        [DefaultValue("")]
        public string _Proveedor
        {
            get
            {
                return Convert.ToString(_Campo("PROVEEDOR"));
            }
            set
            {
                _Campo("PROVEEDOR", value);

                string lcProveedor = "";

                lcProveedor = FUNCTIONS._Punto_Por_Ceros(value);
                if (this._oProveedor == null)
                {
                    this._oProveedor = new Cuenta(lcProveedor);
                }
                else if (lcProveedor != this._oProveedor._Codigo)
                {
                    this._oProveedor._Codigo = lcProveedor;
                }
            }
        }


        public Cuenta _oProveedor
        {
            get
            {
                return _oProv;
            }
            set
            {
                _oProv = value;
            }
        }
        private Cuenta _oProv = null;


        [DefaultValue(null)]
        public DateTime? _Fecha_Emision
        {
            get
            {
                object loFecha = _Campo("FECHA_EXPE");
                if (loFecha != DBNull.Value && loFecha != null)
                {
                    _Campo("FECHA_EXPE", ((DateTime)loFecha).Date);
                    return ((DateTime)loFecha).Date;
                }
                else
                    return null;
            }
            set { 
                if (value != null)
                    _Campo("FECHA_EXPE", ((DateTime)value).Date);
                else
                    _Campo("FECHA_EXPE", null);
            }
        }


        [DefaultValue(null)]
        public DateTime? _Fecha_Emision_Origen { get; set; }


        [DefaultValue(null)]
        public DateTime? _Fecha_Vencim
        {
            get
            {
                object loFecha = _Campo("F_VTO");
                if (loFecha != DBNull.Value && loFecha != null)
                {
                    _Campo("F_VTO", ((DateTime)loFecha).Date);
                    return ((DateTime)loFecha).Date;
                }
                else
                    return null;
            }
            set {
                if (value != null)
                    _Campo("F_VTO", ((DateTime)value).Date);
                else
                    _Campo("F_VTO", null);
                }
        }


        [DefaultValue(0.0)]
        public decimal _Importe
        {
            get { return Convert.ToDecimal(_Campo("IMPORTE")); }
            set { _Campo("IMPORTE", value); }
        }


        [DefaultValue(0.0)]
        public decimal _Importe_Origen { get; set; }


        public bool _Cheque
        {
            get { return Convert.ToBoolean(_Campo("CHEQUE")); }
            set { _Campo("CHEQUE", value); }
        }


        [DefaultValue("")]
        public string _Asiento
        {
            get { return Convert.ToString(_Campo("ASIENTO")); }
            set { _Campo("ASIENTO", value); }
        }


        [DefaultValue("")]
        public string _AsiEfectos
        {
            get { return Convert.ToString(_Campo("ASI_EFECTOS")); }
            set { _Campo("ASI_EFECTOS", value); }
        }


        public DataTable _Previsiones { get; set; }


        public override string _Nombre
        {
            get
            {
                return String.Format("PAGARE{0}", _Pagare);
            }
            set
            {
                ;
            }
        }


        #region IDocumentoImprimible

        
        public string _ReportBase
        {
            get
            {
                return "PAGARE";
            }
            set
            {
                ;
            }
        }

        
        public String _ReportTitlePreview
        {
            get
            {
                return "Pagaré de pago";
            }
            set
            {
                ;
            }
        }


        public IDocPrint _DocPrint
        {
            get
            {
                if (_oDocPrint == null)
                {
                    _oDocPrint = (DocPrintPagarePago)Activator.CreateInstance(typeof(DocPrintPagarePago), this);
                }

                return (DocPrintPagarePago)_oDocPrint;
            }
            set
            {
                _oDocPrint = (DocPrintPagarePago)value;
            }
        }
        private DocPrintPagarePago _oDocPrint;

        public string _Fecha
        {
            get
            {
                return DateTime.Now.ToShortDateString();
            }
        }


        #endregion IDocumentoImprimible


        #endregion PROPIEDADES PUBLICAS


        #region CONSTRUCTORES


        public PagarePago()
        {
            this.establecerParametros();

            this._Load();

            return;
        }


        public PagarePago(string tcEmpresa = "", string tcBanco = "", string tcPagare = "")
        {
            if (string.IsNullOrWhiteSpace(tcEmpresa) || string.IsNullOrWhiteSpace(tcBanco) || string.IsNullOrWhiteSpace(tcPagare))
            {
                this._Error_Message = "Parámetros incorrectos.";
                return;
            }

            this.establecerParametros();

            this._Empresa = tcEmpresa;
            this._Banco = tcBanco;
            this._Pagare = tcPagare;

            this._Load();

            return;
        }


        public PagarePago(DataRow loRow)
        {
            string lcEmpresa = Convert.ToString(loRow["empresa"]);
            string lcBanco = Convert.ToString(loRow["banco"]);
            string lcPagare = Convert.ToString(loRow["pagare"]);

            if (string.IsNullOrWhiteSpace(lcEmpresa) || string.IsNullOrWhiteSpace(lcBanco) || string.IsNullOrWhiteSpace(lcPagare))
            {
                this._Error_Message = "Parámetros incorrectos.";
                return;
            }
            this.establecerParametros();

            this._Empresa = lcEmpresa;
            this._Banco = lcBanco;
            this._Pagare = lcPagare;

            this._Load();

            return;
        }


        #endregion CONSTRUCTORES


        #region METODOS PRIVADOS


        private bool controlesAsentarPagaresCtaEfectos()
        {
            bool llExisteAsientoAsiento = false, llOk = true;

            if (!string.IsNullOrWhiteSpace(this._AsiEfectos))
            {
                Asientos loAsiento = new Asientos(this._AsiEfectos);
                if (loAsiento._Numero != 0 && loAsiento._Lineas.Count > 0)
                    llExisteAsientoAsiento = true;
            }
            if (!llExisteAsientoAsiento)
            {
                if (!this._ExisteAsientoEfectosEjerAnt())
                {
                    llOk = this.generarAsientoEfectos();
                }
            }
            else
            {
                if (this._Importe != this._Importe_Origen ||
                    this._Fecha_Emision != this._Fecha_Emision_Origen)
                {
                    if (!string.IsNullOrWhiteSpace(this._AsiEfectos))
                    {
                        this.borrarAsientoEfectos();
                    }
                    llOk = this.generarAsientoEfectos();
                }
            }

            return llOk;
        }


        private bool generarAsientoEfectos()
        {
            bool llOk = false;

            DateTime ldtFechaAsiento = Convert.ToDateTime(this._Fecha_Emision);

            Asientos loAsiento = new Asientos();
            loAsiento._New(this._cEmpresa, eTipoOrigenAsiento.Defecto);
            loAsiento._Fecha = ldtFechaAsiento;
            loAsiento._Divisa = this._cMonedaEmpresa;
            loAsiento._Cambio = 1;
            loAsiento._Tipo_mov = 31;

            bool llSel = false;
            string lcFactura = "", lcDefinicion = "";
            int lnOrden = 0;
            decimal lnImporte = 0;

            foreach (DataRow loRow in this._Previsiones.Rows)
            {
                llSel = Convert.ToBoolean(loRow["sel"]);
                if (llSel)
                {
                    lcFactura = Convert.ToString(loRow["factura"]);
                    lnOrden = Convert.ToInt32(loRow["numereb"]);
                    lnImporte = Convert.ToDecimal(loRow["importe"]);

                    lcDefinicion = "Pago factura " + lcFactura.Trim() + "/" + Convert.ToString(lnOrden) + " en pagaré " + this._Pagare;
                    this.asientoNuevaLinea(loAsiento, this._Proveedor, lcDefinicion, 1, "D", lnImporte);
                }
            }

            // Crea la cuenta de efectos respectiva si no existe.
            //
            string lcCtaEfectos = this.cuentaEfectos(this._Proveedor);

            this.asientoNuevaLinea(loAsiento, lcCtaEfectos, "Pagaré " + this._Pagare, 1, "H", this._Importe);

            // Grabo el asiento.
            //
            llOk = loAsiento._Save();

            if (!llOk)
            {
                this._Error_Message = "No se ha podido generar el asiento del pagaré utilizando cuenta de efectos a pagar." + Environment.NewLine + Environment.NewLine +
                                      "Mensaje de error: " + loAsiento._Mensaje_Error;
                return false;
            }
            else
            {
                this._AsiEfectos = loAsiento._Lineas[0]._Asi;
            }

            return llOk;
        }


        private bool borrarAsientoEfectos()
        {
            bool llOk = true;

            if (!string.IsNullOrWhiteSpace(this._AsiEfectos))
            {
                Asientos loAsiento = new Asientos(this._AsiEfectos);
                if (loAsiento._Numero != 0 && loAsiento._Lineas.Count > 0)
                    loAsiento._Delete();

                loAsiento = null;

                this._AsiEfectos = "";

                // No poner aqui un this._Save() en ningún caso, sino al borrar un pagaré no borrará el registro de PAGARE_P por que lo volverá
                // a insertar
            }

            return llOk;
        }


        private bool asientoPeriodoCerrado(string tcAsi)
        {
            if (string.IsNullOrWhiteSpace(tcAsi))
                return false;

            Asientos loAsiento = new Asientos(tcAsi);
            if (loAsiento._Numero != 0 && loAsiento._Lineas.Count > 0)
            {
                DateTime ldtFechaAsiento = loAsiento._Fecha;

                // Controlar que el mes de la fecha del asiento declarado no esté cerrado.
                //
                if (FUNCTIONS._Comprovar_Mes_Cerrado(ldtFechaAsiento))
                {
                    this._Error_Message = "No se puede desasentar el pagaré, la fecha del asiento (" + ldtFechaAsiento.ToShortDateString() + ") corresponde a un mes cerrado contablemente.";
                    return true;
                }
            }

            return false;
        }


        private void establecerParametros()
        {
            _Browser_Titulos_Campos = "Banco, Pagaré, Proveedor, Nombre, Importe, F.Emisión, F.Vencimiento, Contabilizado";
            _Browser_Campos = "p.banco, p.pagare, p.proveedor, " + DB.SQLNvl("c.nombre", "''") + " as nombre, p.importe, p.fecha_expe, p.f_vto, " + DB.SQLIif("p.asiento = ' ' ", DB.SQLFalse(), DB.SQLTrue()) + " as contabilizado ";
            _Browser_Campos_No_Visibles = "p.empresa";

            _Browser_Campo_Predet = "pagare ";
            _Browser_Tabla = "pagare_p p inner join " + CONTABILIDAD._CuentasProveedores("codigo, nombre") + " c on p.proveedor = c.codigo ";
            _Browser_Clave = "empresa,banco,pagare";
            _Browser_Condicion = "empresa= " + DB.SQLString(_cEmpresa);

            _Clave = "empresa,banco,pagare";
            _DataBase = "GESTION";
            _Tabla = "PAGARE_P";
            _TituloMantenimiento = "Emisión de pagarés";
            _Pregunta_Borrar = "¿Desea eliminar el pagaré?";
            _FormManteBaseType = typeof(frmPagarePagoMante);

            Navegacion._Condicion = "empresa=" + DB.SQLString(_cEmpresa);

            return;
        }


        private string cuentaEfectos(string tcCuenta)
        {
            string tcCuentaEfecto = "";
            string lcCuentaProv = Convert.ToString(EW_GLOBAL._GetVariable("wc_proveed"));
            string lcCuentaAcre = Convert.ToString(EW_GLOBAL._GetVariable("wc_acreed"));

            if (tcCuenta.Substring(0, 3) == this._cProveedor.Substring(0, 3) && !string.IsNullOrWhiteSpace(this._cEfecProv))
                tcCuentaEfecto = this._cEfecProv.Substring(0, 3) + tcCuenta.Substring(3, this._nDigitos-3);
            else
            {
                if (tcCuenta.Substring(0, 3) == this._cAcreedor.Substring(0, 3) && !string.IsNullOrWhiteSpace(this._cEfecAcre))
                    tcCuentaEfecto = this._cEfecAcre.Substring(0, 3) + tcCuenta.Substring(3, this._nDigitos - 3); 
                else
                    tcCuentaEfecto = tcCuenta.Substring(0, 2) + "1" + tcCuenta.Substring(3, this._nDigitos - 3);
            }

            Cuenta loCuenta = new Cuenta();
            loCuenta._Codigo = tcCuenta;

            // Asegurar la existencia de la cuenta.
            //
            CONTABILIDAD._CrearCuentaContable(tcCuentaEfecto, loCuenta._Nombre);

            return tcCuentaEfecto;
        }


        private void asientoNuevaLinea(Asientos toAsiento, string tcCuenta, string tcDefinicion, decimal tnCambio, string tcDebeHaber, decimal tnImporte)
        {
            AsientosLinea loAsientoLinea = new AsientosLinea(toAsiento);
            int lnLinia = toAsiento._MaxLinea + 1;
            loAsientoLinea._Linea = lnLinia;

            loAsientoLinea._Cuenta = tcCuenta;
            loAsientoLinea._Definicion = tcDefinicion;
            loAsientoLinea._Cambio = tnCambio;

            if (tcDebeHaber == "D")
            {
                loAsientoLinea._Debe = tnImporte;
                loAsientoLinea._Haber = 0;
            }
            else
            {
                loAsientoLinea._Haber = tnImporte;
                loAsientoLinea._Debe = 0;
            }

            toAsiento._AddLinea(loAsientoLinea);

            return;
        }


        private bool enlacePrevisionPagare(string tcEmpresa, int tnPeriodo, string tcProveedor, string tcFactura, int tnOrden, int tnPendiente, bool tlEnlazar)
        {
            bool llOk = true;

            try
            {
                PrevisionPago loPrevision = new PrevisionPago();
                loPrevision._Empresa = tcEmpresa;
                loPrevision._Ejercicio = tnPeriodo;
                loPrevision._Proveedor = tcProveedor;
                loPrevision._Factura = tcFactura;
                loPrevision._Numereb = tnOrden;
                loPrevision._Pendiente = tnPendiente;
                loPrevision._Load();

                if (loPrevision._Estado == _EstadosMantenimiento.MostrandoRegistro)
                {
                    if (tlEnlazar)
                    {
                        loPrevision._Num_Pag = this._Pagare;
                        loPrevision._Imppagare = this._Importe;
                        loPrevision._Fecha_Vencim2 = this._Fecha_Vencim;
                        loPrevision._Banco = this._Banco;
                        loPrevision._Cheque = this._Cheque;
                    }
                    else
                    {
                        loPrevision._Num_Pag = "";
                        loPrevision._Imppagare = 0;
                        loPrevision._Fecha_Vencim2 = null;
                        loPrevision._Cheque = false;
                    }

                    llOk = loPrevision._Save();

                    if (!llOk)
                        this._Error_Message = "No se pudieron actualizar los campos de enlace de la previsión de pago de la Factura " + tcFactura.Trim() + " Orden " + tnOrden.ToString() + " Proveedor " + tcProveedor.Trim() + " con el pagaré.";
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            return llOk;
        }


        private void nuevaPrevision(int tnPeriodo, string tcProveedor, string tcFactura, int tnOrden, int tnPendiente, decimal tnImporte)
        {
            DataTable ldtMaxOrden = new DataTable();
            int lnNuevoOrden = 0;
            bool llOk = false;

            // Averiguo el nº de orden de la nueva previsión a crear a partir de los datos de la previsión recibidos por parámetros.
            // El campo NUMEREB de esta previsión será el máximo NUMEREB que encuentre + 1.
            //
            string lcSql = "select max(numereb) as maxorden from " + DB.SQLDatabase("comunes", "previs") + " " +
                           "where empresa=" + DB.SQLString(this._cEmpresa) + " and " +
                           "periodo=" + DB.SQLString(tnPeriodo) + " and " +
                           "proveedor=" + DB.SQLString(tcProveedor) + " and " +
                           "factura=" + DB.SQLString(tcFactura);
            DB.SQLExec(lcSql, ref ldtMaxOrden);

            if (ldtMaxOrden.Rows.Count > 0)
                lnNuevoOrden = Convert.ToInt32(ldtMaxOrden.Rows[0]["maxorden"]) + 1;
            else
                lnNuevoOrden = 1;

            // Previsión de pago original a partir de la que crearemos la nueva previsión.
            //
            PrevisionPago loPrevisionOriginal = new PrevisionPago();
            loPrevisionOriginal._Empresa = this._cEmpresa;
            loPrevisionOriginal._Ejercicio = tnPeriodo;
            loPrevisionOriginal._Proveedor = tcProveedor;
            loPrevisionOriginal._Factura = tcFactura;
            loPrevisionOriginal._Numereb = tnOrden;
            loPrevisionOriginal._Pendiente = tnPendiente;
            loPrevisionOriginal._Load();

            // Creo la nueva previsión de pago.
            //
            PrevisionPago loPrevisionNueva = new PrevisionPago();
            loPrevisionNueva._New(loPrevisionOriginal._Proveedor, this._cEmpresa, tcFactura,
                                lnNuevoOrden, 0,
                                tnImporte, Convert.ToDateTime(loPrevisionOriginal._Fecha_Emision),
                                Convert.ToDateTime(loPrevisionOriginal._Fecha_Vencim),
                                this._cMonedaEmpresa, loPrevisionOriginal._Num_Banco,
                                loPrevisionOriginal._Banco,
                                loPrevisionOriginal._Referencia, 
                                (loPrevisionOriginal._Fecha_Operacion == null ? loPrevisionOriginal._Fecha_Operacion : Convert.ToDateTime(loPrevisionOriginal._Fecha_Operacion)),
                                loPrevisionOriginal._Forma_Pago,
                                loPrevisionOriginal._Recc, loPrevisionOriginal._Ejercicio, loPrevisionOriginal._Cambio, tnImporte);

            // Una vez creada la previsión, la cargo para asegurar algunos datos de la misma.
            //
            loPrevisionNueva = new PrevisionPago();
            loPrevisionNueva._Empresa = this._cEmpresa;
            loPrevisionNueva._Ejercicio = tnPeriodo;
            loPrevisionNueva._Proveedor = tcProveedor;
            loPrevisionNueva._Factura = tcFactura;
            loPrevisionNueva._Numereb = lnNuevoOrden;
            loPrevisionNueva._Pendiente = 0;
            loPrevisionNueva._Load();

            if (loPrevisionNueva._Estado == _EstadosMantenimiento.MostrandoRegistro)
            {
                loPrevisionNueva._Concepto = "Generada por emisión pagaré: " + this._Pagare.Trim() + " (diferencia de total pagaré)";
                loPrevisionNueva._Asiento = false;
                loPrevisionNueva._Remesa = 0;
                loPrevisionNueva._Asi = "";
                loPrevisionNueva._Refundir = "";
                loPrevisionNueva._Imppagare = 0;
                loPrevisionNueva._Num_Pag = "";
                loPrevisionNueva._Pagada = "N";
                loPrevisionNueva._Fecha_Vencim2 = null;
                llOk = loPrevisionNueva._Save();

                if (!llOk)
                {
                    this._Error_Message = "No se ha podido actualizar la nueva previsión por la diferencia para la Factura " + tcFactura.Trim() + " Orden " + lnNuevoOrden.ToString() + " Proveedor " + tcProveedor;
                }
                else
                {
                    // Actualizo el importe de la previsión original.
                    //
                    decimal lnNuevoImporte = (loPrevisionOriginal._Importe - tnImporte);
                    loPrevisionOriginal._Importe = lnNuevoImporte;
                    loPrevisionOriginal._ImporteDiv = lnNuevoImporte;
                    llOk = loPrevisionOriginal._Save();
                    if (!llOk)
                        this._Error_Message = "No se ha podido actualizar la previsión original para la Factura " + tcFactura.Trim() + " Orden " + tnOrden.ToString() + " Proveedor " + tcProveedor;
                    else
                    {
                        if (this._LinkForm)
                        {
                            Divisa loDivisa = new Divisa(this._cMonedaEmpresa);
                            ewMascara loMascara = loDivisa._MascaraImporte;
                            FUNCTIONS._MessageBox("Se ha generado una nueva previsión para la factura " + tcFactura.Trim() + " proveeedor " + tcProveedor + " con un importe de " + tnImporte.ToString(loMascara._Mascara_Net), "Emisión de pagarés",
                                                  System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Stop, System.Windows.Forms.MessageBoxDefaultButton.Button1);
                        }
                    }
                }
            }

            return;
        }


        private bool actCamposPagoEnPrevis(string tcEmpresa, int tnPeriodo, string tcProveedor, string tcFactura, int tnOrden, int tnPendiente, string tcAsi, DateTime tdFechaAsiento)
        {
            bool llOk = true;

            try
            {
                PrevisionPago loPrevision = new PrevisionPago();
                loPrevision._Empresa = tcEmpresa;
                loPrevision._Ejercicio = tnPeriodo;
                loPrevision._Proveedor = tcProveedor;
                loPrevision._Factura = tcFactura;
                loPrevision._Numereb = tnOrden;
                loPrevision._Pendiente = tnPendiente;
                loPrevision._Load();

                if (loPrevision._Estado == _EstadosMantenimiento.MostrandoRegistro)
                {
                    loPrevision._Pagada = "S";
                    loPrevision._Asiento = true;
                    loPrevision._Asi = tcAsi;
                    loPrevision._Fecha_Pago = tdFechaAsiento;
                    llOk = loPrevision._Save();

                    if (!llOk)
                        this._Error_Message = "No se pudieron actualizar los campos de pago en la previsión de pago Proveedor " + tcProveedor + " Factura " + tcFactura.Trim() + " Orden " + tnOrden.ToString() +
                                              Environment.NewLine + Environment.NewLine + loPrevision._Error_Message;
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            return llOk;
        }


        #endregion METODOS PRIVADOS


        #region MÉTODOS PROTECTED OVERRIDE


        protected override void _DescargarDatos()
        {
            base._DescargarDatos();

            this._oProv = null;
            this._Importe_Origen = 0;
            this._Fecha_Emision_Origen = null;

            if (this._Previsiones is DataTable && this._Previsiones.Rows.Count > 0)
                this._Previsiones.Clear();

            return;
        }


        #endregion MÉTODOS PROTECTED OVERRIDE


        #region MÉTODOS PÚBLICOS


        public bool _Print()
        {
            DataTable loDt;
            DocPrintPagarePago loDocPrint = _DocPrint as DocPrintPagarePago;

            loDocPrint._MaxFechaEmision = Convert.ToDateTime(_Fecha_Vencim);
            loDocPrint._FechaEmision = Convert.ToDateTime(_Fecha_Emision);

            loDt = CONTABILIDAD._ObtenerDatosEntidadCtaContableBanco(_Banco);

            if (loDt.Rows.Count > 0)
            {
                loDocPrint._CodigoEntidad = Convert.ToString(loDt.Rows[0]["CODIGO"]);
                loDocPrint._CodigoBanco = Convert.ToString(loDt.Rows[0]["CODBANCO"]);
                loDocPrint._CodigoCarta = Convert.ToString(loDt.Rows[0]["CARTAPAG"]);
            }

            if (loDocPrint._Show_Print())
            {
                return loDocPrint._Print();
            }

            return false;
        }


        public DataTable _SeleccionarPrevisiones(DateTime tdFEmisionIni, DateTime tdFEmisionFin)
        {
            DataTable ldtPrevisionesPendientes = new DataTable();

            // Seleccionamos las previsiones pendientes del proveedor, y las propias que tenga ya incorporadas al pagaré, hacemos un UNION
            // de las dos consultas.
            //
            string lcSql = "select empresa, proveedor, factura, numereb, pendiente, emision, periodo, vencim, importe, banco, " + DB.SQLFalse() + " as sel " +
                           "from " + DB.SQLDatabase("comunes", "previs") + " " +
                           "where empresa=" + DB.SQLString(this._cEmpresa) + " and " +
                           "proveedor=" + DB.SQLString(this._Proveedor) + " and " +
                           "banco=" + DB.SQLString(this._Banco) + " and " +
                           "emision>=" + DB.SQLString(tdFEmisionIni) + " and emision <= " + DB.SQLString(tdFEmisionFin) + " and " +
                           "num_pag=" + DB.SQLString(" ") + " and " +
                           "asiento=" + DB.SQLFalse() + " and " +
                           "remesa=0 and  " +
                           "refundir=" + DB.SQLString(" ") + " " +
                           "union all " +
                           "select  empresa, proveedor, factura, numereb, pendiente, emision, periodo, vencim, importe, banco, " + DB.SQLTrue() + " as sel " +
                           "from " + DB.SQLDatabase("comunes", "previs") + " " +
                           "where empresa=" + DB.SQLString(this._cEmpresa) + " and " +
                           "banco=" + DB.SQLString(this._Banco) + " and " +
                           "num_pag=" + DB.SQLString(this._Pagare) + " " +
                           "order by factura, numereb, emision";
            bool llOk = DB.SQLExec(lcSql, ref ldtPrevisionesPendientes);

            return ldtPrevisionesPendientes;
        }


        public void _Show_Asiento()
        {
            if (string.IsNullOrWhiteSpace(this._Asiento))
                return;

            Asientos loAsiento = new Asientos(this._Asiento);
            loAsiento._Show();

            return;
        }


        public bool _ExistePagare(string tcEmpresa, string tcBanco, string tcPagare)
        {
            bool llOk = false;

            DataTable ldtPagare = new DataTable();
            string lcSql = "Select empresa, banco, pagare " +
                           "From " + DB.SQLDatabase("gestion", "pagare_p") + " " +
                           "where empresa =" + DB.SQLString(tcEmpresa) + " and " +
                           "banco =" + DB.SQLString(tcBanco) + " and " +
                           "pagare =" + DB.SQLString(tcPagare);
            DB.SQLExec(lcSql, ref ldtPagare);

            if (ldtPagare.Rows.Count > 0)
                llOk = true;

            return llOk;
        }


        public bool _ExistePagareEjerPost(ref string tcMensaje)
        {
            bool llExiste = false;

            string lcAsi = "";
            DataTable ldtDatosPagare = new DataTable();
            tcMensaje = "";

            // Verificar la existencia de ejercicios posteriores al actual.
            //
            DataTable ldtEjerPost = new DataTable();
            string lcSql = "select * from " + DB.SQLDatabase("comunes", "ejercici") + " " +
                           "where [any]>" + this._lcAny + " " +
                           "order by [any]";
            DB.SQLExec(lcSql, ref ldtEjerPost);

            if (ldtEjerPost.Rows.Count == 0)
                return false;

            string lcEjercicio = "", lcBdEjercicio="";

            foreach (DataRow loRow in ldtEjerPost.Rows)
            {
                // Buscamos el pagaré en el ejercicio que estamos procesando.
                //
                lcEjercicio = Convert.ToString(loRow["any"]).Trim();
                lcBdEjercicio = Convert.ToString(loRow["conexion"]).Trim();

                lcSql = "select empresa, banco, pagare " +
                        "from " + DB.SQLDatabaseReal(lcBdEjercicio, "pagare_p") + " " +
                        "where empresa=" + DB.SQLString(this._Empresa) + " and " +
                        "banco = " + DB.SQLString(this._Banco) + " and " +
                        "pagare = " + DB.SQLString(this._Pagare);
                DB.SQLExec(lcSql, ref ldtDatosPagare);

                if (ldtDatosPagare.Rows.Count > 0)
                {
                    llExiste = true;

                    tcMensaje = "Se han encontrado el pagaré en periodos posteriores al actual, debe eliminar el pagaré en el ejercicio " + lcEjercicio + " posterior al actual.";

                    lcAsi = Convert.ToString(ldtDatosPagare.Rows[0]["asiento"]);

                    if (!string.IsNullOrWhiteSpace(lcAsi))
                    {
                        tcMensaje += Environment.NewLine + Environment.NewLine + "El pagaré # " + this._Pagare + " tiene el asiento en el ejercicio " +
                                     lcEjercicio + ". Si quiere eliminarlo deberá hacerlo desde ese ejercicio.";
                    }
                }
            }

            return llExiste;
        }


        public bool _ExisteAsientoEfectosEjerAnt()
        {
            bool llOk = false;

            if (string.IsNullOrWhiteSpace(this._AsiEfectos))
                return false;

            // Verificar la existencia del ejercicio anterior al actual.
            //
            DataTable ldtEjercicios = new DataTable();
            DB.SQLExec("select * from " + DB.SQLDatabase("comunes", "ejercici"), ref ldtEjercicios);

            List<string> lstEjercicios = (from loRow in ldtEjercicios.AsEnumerable()
                                          select Convert.ToString(loRow["any"]).Trim()).ToList();

            bool llExisteEjerAnt = lstEjercicios.Contains(Convert.ToString(Convert.ToInt32(this._lcAny) - 1));

            if (llExisteEjerAnt)
            {
                // Busco el ASI en la tabla de asientos del ejercicio anterior.
                //
                int lnNumeroAsiento = Convert.ToInt32(DB.SQLValor("asientos", "ASI", this._AsiEfectos, "NUMERO", "GESTION-1"));
                if (lnNumeroAsiento != 0)
                    llOk = true;
            }

            return llOk;
        }


        public bool _Restar_Numero_Pagare()
        {
            bool llOk = false;
            int lnNumPagare = 0;
            string lcSerie = "";

            // Capto la serie del pagaré.
            //
            if (this._Pagare.Trim().Length >= 3)
                lcSerie = this._Pagare.Trim().Substring(0, 3);

            // Capto el nº de pagaré.
            //
            if (this._Pagare.Trim().Length >= 4)
            {
                llOk = Int32.TryParse(this._Pagare.Substring(3), out lnNumPagare); // El número de pagaré es serie + número  (3dígitos + 7dígitos)

                if (llOk)
                {
                    string lcCodigoBanco = Convert.ToString(DB.SQLValor("bancos", "cuenta", this._Banco, "codigo"));
                    if (!string.IsNullOrWhiteSpace(lcCodigoBanco))
                    {
                        CuentaBancaria loBanco = new CuentaBancaria(lcCodigoBanco);
                        bool llRestar = (Convert.ToInt32(loBanco._Numero) == lnNumPagare);
                        if (llRestar)
                        {
                            if (!string.IsNullOrWhiteSpace(loBanco._Serie) && lcSerie != loBanco._Serie)
                                llRestar = false;
                        }

                        if (llRestar)
                        {
                            loBanco._Numero = loBanco._Numero - 1;
                            loBanco._Save();
                            return true;
                        }
                    }
                }
            }

            return false;
        }


        public bool _DesAsentarPagare()
        {
            DataTable ldtPagares = new DataTable();
            bool llOk = true, llPeriodoCerrado=false;
            DateTime ldtFechaAsiento = DateTime.Today;
            Asientos loAsiento = null;
            string lcAsiNormal = "";

            try
            {
                if (!string.IsNullOrWhiteSpace(this._Asiento))
                {
                    llPeriodoCerrado = this.asientoPeriodoCerrado(this._Asiento);
                    if (llPeriodoCerrado)
                        return false;
                    lcAsiNormal = this._Asiento;
                }

                this._Asiento = "";

                llOk = this._Save();
                if (!llOk)
                {
                    this._Error_Message = "No se ha podido desasentar el pagaré.";
                }
                else
                {
                    // Desmarco las previsiones de que se compone el pagaré para dejarlas "libres".
                    //
                    string lcEmpresa = "", lcProveedor = "", lcFactura = "";
                    int lnPeriodo = 0, lnOrden = 0, lnPendiente = 0;
                    bool llSel = false;
                    foreach (DataRow loRowPrevis in this._Previsiones.Rows)
                    {
                        lcEmpresa = Convert.ToString(loRowPrevis["empresa"]);
                        lnPeriodo = Convert.ToInt32(loRowPrevis["periodo"]);
                        lcProveedor = Convert.ToString(loRowPrevis["proveedor"]);
                        lcFactura = Convert.ToString(loRowPrevis["factura"]);
                        lnOrden = Convert.ToInt32(loRowPrevis["numereb"]);
                        lnPendiente = Convert.ToInt32(loRowPrevis["pendiente"]);
                        llSel = Convert.ToBoolean(loRowPrevis["sel"]);

                        if (llSel)
                        {
                            PrevisionPago loPrevisionPago = new PrevisionPago();
                            loPrevisionPago._Empresa = lcEmpresa;
                            loPrevisionPago._Ejercicio = lnPeriodo;
                            loPrevisionPago._Proveedor = lcProveedor;
                            loPrevisionPago._Factura = lcFactura;
                            loPrevisionPago._Numereb = lnOrden;
                            loPrevisionPago._Pendiente = lnPendiente;
                            loPrevisionPago._Load();
                            if (loPrevisionPago._Estado == _EstadosMantenimiento.MostrandoRegistro)
                                loPrevisionPago._Desasentar();  // Esto borra unicamente los campos ASI, ASIENTO, PAGADA, FECHA_PAGO y hace el _Save() de la previsión.
                        }
                    }

                    if (!string.IsNullOrWhiteSpace(lcAsiNormal))
                    {
                        loAsiento = new Asientos(lcAsiNormal);

                        // Elimino el asiento del pagaré.
                        //
                        if (loAsiento != null && loAsiento._Numero != 0 && loAsiento._Lineas.Count > 0)
                        {
                            llOk = loAsiento._Delete();
                            if (!llOk)
                            {
                                this._Error_Message = "No se ha podido eliminar el asiento del pagaré nº " + Convert.ToString(loAsiento._Numero);
                                return false;
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            return llOk;
        }


        public bool _Permite_Delete_Pagare()
        {
            if (!string.IsNullOrWhiteSpace(this._Asiento))
            {
                if (this._LinkForm)
                    FUNCTIONS._MessageBox("El pagaré ya está contabilizado." + Environment.NewLine + Environment.NewLine + "Imposible eliminar pagaré.", "Pagarés de pago",
                                           System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Stop, System.Windows.Forms.MessageBoxDefaultButton.Button1);
                return false;
            }

            return true;
        }


        public void _DescartarPrevisionesNoSelec()
        {
            for (int i = this._Previsiones.Rows.Count - 1; i >= 0; i--)
            {
                DataRow row = this._Previsiones.Rows[i];
                if (Convert.ToBoolean(row["sel"]) == false)
                    this._Previsiones.Rows.Remove(row);
            }
            this._Previsiones.AcceptChanges();

            return;
        }


        public bool _EnlacePrevisionesPagare(bool tlDesenlazarForzado = false, bool tlCrearNuevaPrevision = false, int tnPeriodo = 0,
                                             string tcProveedor = "", string tcFactura = "", int tnOrden = 0, int tnPendiente = 0,
                                             decimal tnImporte = 0)
        {
            bool llActuOk = true, llSel = false;
            string lcEmpresa = "", lcFactura = "", lcProveedor = "";
            int lnPeriodo = 0, lnOrden = 0, lnPendiente = 0;

            try
            {
                // Aqui se enlaza, y se desenlaza también, pues podría pasar que una previsión que tuvieramos enlazada con un pagaré, ahora
                // no quisiesemos que formase parte de él.
                //
                foreach (DataRow loRowPrevis in this._Previsiones.Rows)
                {
                    lcEmpresa = Convert.ToString(loRowPrevis["empresa"]);
                    lnPeriodo = Convert.ToInt32(loRowPrevis["periodo"]);
                    lcProveedor = Convert.ToString(loRowPrevis["proveedor"]);
                    lcFactura = Convert.ToString(loRowPrevis["factura"]);
                    lnOrden = Convert.ToInt32(loRowPrevis["numereb"]);
                    lnPendiente = Convert.ToInt32(loRowPrevis["pendiente"]);

                    llSel = tlDesenlazarForzado ? false : Convert.ToBoolean(loRowPrevis["sel"]);

                    llActuOk = this.enlacePrevisionPagare(lcEmpresa, lnPeriodo, lcProveedor, lcFactura, lnOrden, lnPendiente, llSel);
                    if (!llActuOk)
                    {
                        // El mensaje de error ya fue rellenado por la llamada anterior.
                        break;
                    }
                }

                // Si se tiene que crear nueva previsión lo hago.
                //
                if (tlCrearNuevaPrevision)
                    this.nuevaPrevision(tnPeriodo, tcProveedor, tcFactura, tnOrden, tnPendiente, tnImporte);
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llActuOk = false;
            }

            return llActuOk;
        }

        public void _Clonar(PagarePago toPagare, string tcEmpresa, string tcBanco, string tcPagare)
        {
            try
            {
                if (toPagare._oProv != null)
                {
                    this._oProv = new Cuenta(toPagare._oProv._Codigo);
                    this._oProv._Load();
                }

                // Hay que establecer los campos de la clave principal primero.
                //
                this._Empresa = tcEmpresa;
                this._Banco = tcBanco;
                this._Pagare = tcPagare;
                this._Proveedor = toPagare._Proveedor;
                this._Cheque = toPagare._Cheque;
                this._Fecha_Emision = toPagare._Fecha_Emision;
                this._Fecha_Emision_Origen = toPagare._Fecha_Emision_Origen;
                this._Fecha_Vencim = toPagare._Fecha_Vencim;
                this._Importe = toPagare._Importe;
                this._Importe_Origen = toPagare._Importe_Origen;
                this._Guid_Id = Guid.NewGuid().ToString().ToUpper();

                // Recordar que en origen, posteriormente a esta llamada, deberán marcarse las previsiones de pago pendientes que pertenecen
                // a este pagaré. No tendría sentido tener un pagaré compuesto de 0 previsiones, no está permitido.
            }
            catch (Exception loEx)
            {
                DB.Registrar_Error(loEx);
            }

            return;
        }


        public bool _ActualizarCamposPagoEnPrevis(string tcAsi, DateTime tdFechaAsiento)
        {
            bool llActuOk = true;
            string lcEmpresa = "", lcFactura = "", lcProveedor="";
            int lnPeriodo, lnOrden = 0, lnPendiente = 0;

            try
            {
                // Actualizar campos cobro en todas las previsiones del pagaré.
                //
                foreach (DataRow loRow in this._Previsiones.Select("sel=true"))
                {
                    lcEmpresa = Convert.ToString(loRow["empresa"]);
                    lnPeriodo = Convert.ToInt32(loRow["periodo"]);
                    lcProveedor = Convert.ToString(loRow["proveedor"]);
                    lcFactura = Convert.ToString(loRow["factura"]);
                    lnOrden = Convert.ToInt32(loRow["numereb"]);
                    lnPendiente = Convert.ToInt32(loRow["pendiente"]);

                    // Actualizar campos de pago en la previsión de pago.
                    //
                    llActuOk = this.actCamposPagoEnPrevis(lcEmpresa, lnPeriodo, lcProveedor, lcFactura, lnOrden, lnPendiente, tcAsi, tdFechaAsiento);
                    if (!llActuOk)
                    {
                        // El mensaje de error ya fue rellenado por la llamada anterior.
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llActuOk = false;
            }

            return llActuOk;
        }


        #region IDocumentoImprimible


        public bool _Show_Print(int tnAbrirEn = 1)
        {
            frmReportAction loForm;
            DocPrint loDocPrint = (DocPrint)_DocPrint;

            loForm = new frmReportAction();
            loForm._UserControlAdicional = loDocPrint._UserControlAdicional;
            loForm._ReportBase = _ReportBase;
            loForm._Nombre = ((IDocumentoImprimible)this)._Nombre;
            loForm._PrinterCopies = Convert.ToInt16(loDocPrint._Numero_Copias);
            loForm._MostrarExportacionCSV = false;
            loForm._MostrarOpcionColores = false;
            loForm._Printer = loDocPrint._Printer;
            loForm._ShowEditMode = false;
            loForm._ShowVistaPreliminar = Debugger.IsAttached;
            loForm._ImpresionNormalMultiple = loDocPrint._ImpresionNormalMultiple;
            loForm._ShowDialog();

            if (loForm.DialogResult == DialogResult.OK)
            {
                loDocPrint._ErrorMessage = "";
                loDocPrint._Vista_Preliminar = loForm._VistaPreliminar;
                loDocPrint._Ruta_Fichero = loForm._FilePath;
                loDocPrint._Numero_Copias = loForm._PrinterCopies;
                loDocPrint._Printer = loForm._Printer;
                loDocPrint._Exportar = loForm._Exportar;
                loDocPrint._EditMode = loForm._EditMode;
                loDocPrint._FieldRandomBackColor = loForm._FieldRandomBackColor;
                loDocPrint._Formato_exportacion = loForm._FormatoExportacion;

                loDocPrint._ObtenerConfigurarionOpcionesImpresionMultiple();

                return ((DocPrintPagarePago)loDocPrint).ValidaFicheroCarta();
            }
            else
            {
                return false;
            }
        }

        public Dictionary<string, object> _Obtener_Filtros_SageReports(Dictionary<string, object> tdicParametros = null)
        {
            DataTable loDt;
            Cuenta loCuenta;
            Boolean lEsCheque;
            CuentaBancaria loBanco;
            DateTime? loFechaEmision;
            Dictionary<string, object> loDic, loDicProv;
            Empresa loEmpresa = new Empresa(_Empresa);
            Proveedor loProveedor;
            
            ewMascara loMascaraImport = new ewMascara(KeyDiccionarioMascara.wc_grantotal);
            String lcCodigoBanco, lcImporteLetras, lcDigitoControlPagare, lcDigitoCodigoPagareCMC7, lcCodigoEntidad;
            String lcCuentaIban, lcEntitadBancaria, lcOficinaBancaria, lcCuentaBancaria, lcCuentaDigitoControl, lcIban, lcBancoIBANPais, lcBancoIBANDigitoControl;

            lEsCheque = tdicParametros is Dictionary<string, object>  && tdicParametros.ContainsKey("EsCheque") ? Convert.ToBoolean(tdicParametros["EsCheque"]) : false;
            loFechaEmision = tdicParametros is Dictionary<string, object> && tdicParametros.ContainsKey("FechaEmision") ? Convert.ToDateTime(tdicParametros["FechaEmision"]) : _Fecha_Emision;
            lcCodigoBanco = tdicParametros is Dictionary<string, object> && tdicParametros.ContainsKey("CodigoBanco") ? Convert.ToString(tdicParametros["CodigoBanco"]) : "";
            lcCodigoEntidad = tdicParametros is Dictionary<string, object> && tdicParametros.ContainsKey("CodigoEntidad") ? Convert.ToString(tdicParametros["CodigoEntidad"]) : "";

            if (!lEsCheque)
            {
                loDic = loEmpresa._Obtener_Filtros_SageReports(tdicParametros);

                if (FUNCTIONS._Es_Proveedor(_Proveedor))
                {
                    loProveedor = new Proveedor(_Proveedor);
                    loDicProv = loProveedor._Obtener_Filtros_SageReports(tdicParametros);
                    loDicProv.Where(f => !loDic.ContainsKey(f.Key)).ToList().ForEach(f => loDic.Add(f.Key, f.Value));
                }
                else
                {
                    loCuenta = new Cuenta(_Proveedor);
                   
                    string lcDomicilio = "", lcPoblacion = "", lcCodPos = "", lcProvincia = "", lcTelefono = "";

                    lcTelefono = loCuenta._Telefono;
                    lcDomicilio = loCuenta._Direccion.Trim();
                    lcPoblacion = loCuenta._Poblacion.Trim();
                    lcCodPos = loCuenta._CodPost.Trim();
                    lcProvincia = loCuenta._Provincia.Trim();
                        
                    //Construcción de los filtros
                    loDic.Add("wc_DireccionProveedor", $"{lcDomicilio}{Environment.NewLine}{lcCodPos} {lcPoblacion}{Environment.NewLine}{lcProvincia}");
                    loDic.Add("wc_Proveedor", _Codigo);
                    loDic.Add("wc_ProveedorNIF", loCuenta._GetCif().Trim());
                    loDic.Add("wc_NombreProveedor2", "");
                    loDic.Add("wc_NombreProveedor", loCuenta._Nombre);
                    loDic.Add("wc_TelefonoProveedor", lcTelefono);
                    loDic.Add("wc_PoblacionProveedor", lcPoblacion);
                    loDic.Add("wc_ProvinciaProveedor", lcProvincia);
                    loDic.Add("wc_CPProveedor", lcCodPos);
                    loDic.Add("wc_DomicilioProveedor", lcDomicilio);

                }
                
                if (String.IsNullOrEmpty(lcCodigoBanco) && !String.IsNullOrEmpty(_Banco))
                {
                    loDt = CONTABILIDAD._ObtenerDatosEntidadCtaContableBanco(_Banco);
                    if (loDt.Rows.Count > 0) lcCodigoBanco = Convert.ToString(loDt.Rows[0]["CODBANCO"]);
                  
                }
           
                loBanco = new CuentaBancaria(lcCodigoBanco);
                
                loDic.Add("wc_Pagare", _Pagare);
                loDic.Add("wc_FechaVencimiento", _Fecha_Vencim is DateTime ? _Fecha_Vencim?.ToShortDateString() : "");
                loDic.Add("wc_FechaExpedicion", loFechaEmision is DateTime ? loFechaEmision?.ToShortDateString() : "");
                loDic.Add("wc_Importe", loMascaraImport.StringFormatNet(_Importe));

                lcImporteLetras = FUNCTIONS._Importe_To_Letras(_Importe.ToString(), EW_GLOBAL._Moneda._Codigo);
                lcImporteLetras = lcImporteLetras.Replace("#", "");
                loDic.Add("wc_ImporteLetras", lcImporteLetras);

                loDic.Add("wc_BancoNombre", loBanco._Nombre);

                lcIban = loBanco._Iban.Trim();
                loDic.Add("wc_BancoIBAN", lcIban);

                lcBancoIBANPais = lcBancoIBANDigitoControl = "";

                if (lcIban.Length > 3)
                {
                    lcBancoIBANPais = loBanco._Iban.Substring(0, 2);
                    lcBancoIBANDigitoControl = loBanco._Iban.Substring(2);
                }
                loDic.Add("wc_BancoIBANPais", lcBancoIBANPais);
                loDic.Add("wc_BancoIBANDigitoControl", lcBancoIBANDigitoControl );
                loDic.Add("wc_BancoDireccion", loBanco._Direccion);
                loDic.Add("wc_BancoPoblacion", loBanco._Poblacion);
                loDic.Add("wc_BancoProvincia", loBanco._Provincia);
                loDic.Add("wc_BancoCP", loBanco._CodPost);
                loDic.Add("wc_BancoCuentaBanco", loBanco._CuentaBanco);
                loDic.Add("wc_BancoCuentaDescontados", loBanco._CuentaDescontados);

                lcEntitadBancaria = lcOficinaBancaria = lcCuentaBancaria = lcCuentaDigitoControl = "";
                lcCuentaIban = loBanco._CuentaIban.Trim();

                if (lcCuentaIban.Length > 19)
                {
                    lcEntitadBancaria = lcCuentaIban.Substring(0, 4);
                    lcOficinaBancaria = lcCuentaIban.Substring(4, 4);
                    lcCuentaDigitoControl = lcCuentaIban.Substring(8, 2);
                    lcCuentaBancaria = lcCuentaIban.Substring(10, 10);
                }

                loDic.Add("wc_BancoCuentaIBAN", loBanco._CuentaIban);
                loDic.Add("wc_BancoCuentaEntidad", lcEntitadBancaria);
                loDic.Add("wc_BancoCuentaSucursal", lcOficinaBancaria);
                loDic.Add("wc_BancoCuentaBancaria", lcCuentaBancaria);
                loDic.Add("wc_BancoCuentaDigitoControl", lcCuentaDigitoControl);

                loDic.Add("wn_NumPrevisiones", _Previsiones is DataTable ? _Previsiones.Rows.Count : 0);

                lcDigitoControlPagare = lcDigitoCodigoPagareCMC7 = "";

                if (!String.IsNullOrEmpty(loBanco._CuentaIban))
                {
                    lcDigitoControlPagare = _GetCodigoControl(_Pagare, loBanco._CuentaIban);
                    lcDigitoCodigoPagareCMC7 = _GetCodigoPagareCMC7(_Pagare, loBanco._CuentaIban, String.Format("{0:0.00}", _Importe));
                }
                
                loDic.Add("wc_DigitoControlPagare", lcDigitoControlPagare);
                loDic.Add("wc_CodigoPagareCMC7", lcDigitoCodigoPagareCMC7);
            }
            else
            {
                loDic = new Dictionary<string, object>();
            }

            return loDic;
        }

        private string _GetCodigoPagareCMC7(String tcPagare, String tcCuentaBancaria, String tcImporte)
        {
            String lcEntitadBancaria,  lcOficinaBancaria, lcCuentaBancaria, lcCodigo = "";

            tcPagare = tcPagare.Trim();
            tcPagare = tcPagare.Trim().Length > 7 ? tcPagare.Substring(tcPagare.Length - 7) : tcPagare.PadLeft(7, '0');

            if (tcCuentaBancaria.Length > 19)
            {
                lcEntitadBancaria = tcCuentaBancaria.Substring(0, 4);
                lcOficinaBancaria = tcCuentaBancaria.Substring(4, 4);
                lcCuentaBancaria = tcCuentaBancaria.Substring(10, 10);
                tcImporte = tcImporte.PadLeft(11);

                lcCodigo = String.Format("C{0}E{1}D {2}E {3}B {4}A {5}C ", tcPagare, lcEntitadBancaria, lcOficinaBancaria, lcCuentaBancaria, lcEntitadBancaria, tcImporte);

            }

            return lcCodigo;
        }

        private String _GetCodigoControl(String tcPagare, String tcCuentaBancaria)
        {
            Int64 lnNum;
            String lcCodigo = "";

            tcPagare = tcPagare.Trim();
            tcPagare = tcPagare.Trim().Length > 7 ? tcPagare.Substring(tcPagare.Length - 7) : tcPagare;

            tcCuentaBancaria = tcCuentaBancaria.Length > 4 ? tcCuentaBancaria.Substring(0, 4) : tcCuentaBancaria;

            if (Int64.TryParse(String.Format("{0}{1}", tcCuentaBancaria, tcPagare), out lnNum)) lcCodigo = Convert.ToString(lnNum % 7);
            
            return lcCodigo; 
        }

        public DataTable _Obtener_Datos_SageReports(Dictionary<string, object> tdicParametros = null)
        {
            DataRow loRow;
            DataTable loDt;
            Boolean lEsCheque;
            String lcColumnName;
            Dictionary<string, object> loColumnsName = new Dictionary<string, object>();
            Dictionary<string, object> loDic;
            
            lEsCheque = tdicParametros.ContainsKey("EsCheque") ? Convert.ToBoolean(tdicParametros["EsCheque"]) : false;

            if (lEsCheque)
            {
                loDt = new DataTable();

                if (tdicParametros.ContainsKey("EsCheque")) tdicParametros.Remove("EsCheque");
                loDic = _Obtener_Filtros_SageReports(tdicParametros);
                
                foreach (KeyValuePair<string, object> loKeyValue in loDic)
                {
                    lcColumnName = loKeyValue.Key.StartsWith("w") && loKeyValue.Key.Substring(2, 1) == "_" ? loKeyValue.Key.Substring(3) : loKeyValue.Key;

                    if (!loColumnsName.ContainsKey(lcColumnName))
                    {
                        loColumnsName.Add(lcColumnName, loKeyValue.Value);
                        loDt.Columns.Add(lcColumnName);
                    }
                }

                loRow = loDt.NewRow();
                foreach (KeyValuePair<string, object> loKeyValue in loColumnsName)
                {
                    loRow[loKeyValue.Key] = loKeyValue.Value;
                }
                loDt.Rows.Add(loRow);
            }
            else
            {
                ewMascara loMascaraImport = new ewbase.ewMascara(ew.global.EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_total));

                loDt = _Previsiones is DataTable ? _Previsiones : _GetPrevisiones();
                if (loDt.Columns.Contains("sel")) loDt.Columns.Remove("sel");
                if (loDt.Columns.Contains("importe") && !loDt.Columns["importe"].ExtendedProperties.ContainsKey("Mascara")) loDt.Columns["importe"].ExtendedProperties.Add("Mascara", loMascaraImport._Mascara_Net);

            }

            return loDt;
        }

        #endregion IDocumentoImprimible


        #endregion MÉTODOS PÚBLICOS


        #region MÉTODOS PÚBLICOS OVERRIDE


        public override void _Load()
        {
           
            _Pantalla = "EM_PAGAR";

            base._Load();

            if (!string.IsNullOrWhiteSpace(this._Proveedor))
            {
                if (this._oProv == null)
                {
                    Cuenta loProveedor = new Cuenta(this._Proveedor);
                    this._oProv = loProveedor;
                }
                else
                {
                    if (this._oProv._Codigo != this._Proveedor)
                        this._oProv._Codigo = this._Proveedor;
                }
            }

            if (!string.IsNullOrWhiteSpace(this._Banco) && !string.IsNullOrWhiteSpace(this._Pagare))
            {
                // La fecha de recepción y fecha de vencimiento, a pesar de que por tablas permiten null, en la práctica no
                // permite dejarlos en blanco la pantalla por tanto, si vienen en blanco, ya les doy el valor por defecto que se les
                // da en pantalla.
                //
                // No ocurre lo mismo con la fecha de ingreso, pues ésta sí que permite no declarla.
                //
                if (this._Fecha_Emision == null || this._Fecha_Emision == DateTime.MinValue)
                    this._Fecha_Emision = DateTime.Today;

                if (this._Fecha_Vencim == null || this._Fecha_Vencim == DateTime.MinValue)
                    this._Fecha_Vencim = DateTime.Today;
            }

            // Guardamos estos valores pues se utilizan en algunos casos.
            //
            this._Fecha_Emision_Origen = this._Fecha_Emision;
            this._Importe_Origen = this._Importe;


            if (!string.IsNullOrWhiteSpace(this._Empresa) && !string.IsNullOrWhiteSpace(this._Banco) && !string.IsNullOrWhiteSpace(this._Pagare))
            {
                this._Previsiones = _GetPrevisiones();
            }

            return;
        }

        private DataTable _GetPrevisiones()
        {
            String lcSql = "";
            DataTable ldtPrevisiones = new DataTable();
            
            // Obtener las previsiones que conforman el pagaré.
            lcSql = "select  empresa, proveedor, factura, numereb, pendiente, emision, periodo, vencim, importe, banco, " + DB.SQLTrue() + " as sel " +
                    "from " + DB.SQLDatabase("comunes", "previs") + " " +
                    "where empresa=" + DB.SQLString(this._cEmpresa) + " and " +
                    "banco=" + DB.SQLString(this._Banco) + " and " +
                    "num_pag=" + DB.SQLString(this._Pagare) + " " +
                    "order by factura, numereb, emision";

            DB.SQLExec(lcSql, ref ldtPrevisiones);

            return ldtPrevisiones;
        }

        public override bool _Delete()
        {
            bool llOK = base._Delete();

            if (llOK)
            {
                // Borrar asiento generado con cuentas de efectos, si lo hubiera.
                //
                if (!string.IsNullOrWhiteSpace(this._AsiEfectos))
                    this.borrarAsientoEfectos();

                // Desenlazar las previsiones de pago del pagaré.
                //
                this._EnlacePrevisionesPagare(true);

                // Restar nº de pagaré si fuera el caso.
                //
                this._Restar_Numero_Pagare();
            }

            return llOK;
        }



        public override bool _Save_Before()
        {
            if (this._Estado != _EstadosMantenimiento.EntrandoNuevo && this._Estado != _EstadosMantenimiento.EditandoRegistro)
                return true;

            // Si está activo este opcflag, la fecha de emisión se utiliza precisamente como fecha del asiento que se hace, es por este motivo
            // que no puede estar vacía.
            //
            if (this._lEfectoPag && (this._Fecha_Emision == null || this._Fecha_Emision == DateTime.MinValue))
            {
                this._Error_Message = "Debe introducir la fecha de emisión del pagaré.";
                return false;
            }

            if (string.IsNullOrWhiteSpace(this._Proveedor))
            {
                this._Error_Message = "Debe introducir el proveedor.";
                return false;
            }

            bool llOk = base._Save_Before();

            if (llOk)
            {
                if (this._lEfectoPag)
                {
                    llOk = this.controlesAsentarPagaresCtaEfectos();
                    if (!llOk)
                        return false;
                }
            }

            return llOk;
        }


        #endregion MÉTODOS PÚBLICOS OVERRIDE
    }

    public class DocPrintPagarePago
        : DocPrint
    {

        private DataTable _oDtEntidades;

        private Boolean _bShowInfo = true;

        private Boolean _bPrintedByFox = false;

        #region ENUMERACIONES


        public enum TipoImpresion
        {
            [Description("Pagaré entidad")]
            PagareEntidad= 0,
            [Description("Formato pagaré estándar")]
            CartaPagareStandar = 1,
            [Description("Formato pagaré entidad")]
            CartaPagareEntidad = 2
        }


        #endregion ENUMERACIONES

        #region PROPIEDADES PÚBLICAS

        public Boolean _ShowInfoFOX
        {
            get
            {
                return _bShowInfo;
            }
            set
            {
                _bShowInfo = value;
            }
        }

        public Boolean _PrintedByFoxEngine
        {
            get
            {
                return _bPrintedByFox;
            }
        }

        public TipoImpresion _TipoImpresion
        {
            get
            {
                return _oTipoImpresion;
            }
            set
            {
                _oTipoImpresion = value;
            }
        }
        private TipoImpresion _oTipoImpresion = TipoImpresion.PagareEntidad;


        public string _CodigoCarta
        {
            get
            {
                return _cCodigoCarta;
            }
            set
            {
                if (_cCodigoCarta != value)
                {
                    _cCodigoCarta = value;
                    _oCarta = null;
                }
            }
        }
        private string _cCodigoCarta = "";


        public string _CodigoEntidad
        {
            get
            {
                return _cCodigoEntidad;
            }
            set
            {
                _cCodigoEntidad = value;
            }
        }
        private string _cCodigoEntidad = "";


        public string _CodigoBanco
        {
            get
            {
                return _cCodigoBanco;
            }
            set
            {
                _cCodigoBanco = value;
            }
        }
        private string _cCodigoBanco = "";


        public DateTime _MaxFechaEmision
        {
            get
            {
                return _oMaxFechaEmision;
            }
            set
            {
                _oMaxFechaEmision = value;
            }
        }
        private DateTime _oMaxFechaEmision = DateTime.MaxValue;


        public DateTime _FechaEmision
        {
            get
            {
                return _oFechaEmision;
            }
            set
            {
                _oFechaEmision = value;
            }
        }
        private DateTime _oFechaEmision = DateTime.Now;

        private Mail500 _Carta
        {
            get
            {
                if (_oCarta == null) _oCarta = new Mail500(_CodigoCarta);
                return _oCarta;
            }
        }

        private Mail500 _oCarta;

        #endregion PROPIEDADES PÚBLICAS

        #region PROPIEDADES PÚBLICAS OVERRIDE


        public override UserControl _UserControlAdicional
        {
            get
            {
                if(_oUserControlAdicional == null)
                {
                    _oUserControlAdicional = new OpcionesImpresionPagares();
                }

                OpcionesImpresionPagares loUserControl = ((OpcionesImpresionPagares)_oUserControlAdicional);

                loUserControl._FechaEmision = _FechaEmision;
                loUserControl._CodigoEntidad = _cCodigoEntidad;
                loUserControl._CodigoBanco = _cCodigoBanco;
                loUserControl._CodigoCarta = _cCodigoCarta;

                return loUserControl;
            }
            set
            {
                if(value is OpcionesImpresionPagares) _oUserControlAdicional = (OpcionesImpresionPagares)value;
            }
        }


        #endregion PROPIEDADES PÚBLICAS OVERRIDE

        #region PROPIEDADES PRIVADAS

        private DataTable _Entidades
        {
            get
            {
                if(_oDtEntidades == null ) _oDtEntidades = CONTABILIDAD._ObtenerDataTableEntidadesBancarias();
                return _oDtEntidades;
            }
        }

        #endregion PROPIEDADES PRIVADAS

        #region CONSTRUCTOR


        public DocPrintPagarePago(IDocumentoImprimible loDocumentoImprimible)
            : base()
        {
            _Documento = loDocumentoImprimible;
        }


        #endregion CONSTRUCTOR


        #region MÉTODOS PÚBLICOS OVERRIDE


        public override void _ObtenerConfigurarionOpcionesImpresionMultiple()
        {
            OpcionesImpresionPagares loUserControl = ((OpcionesImpresionPagares)_oUserControlAdicional);

            _TipoImpresion = loUserControl._TipoImpresion;
            _FechaEmision = loUserControl._FechaEmision;
            _CodigoEntidad = loUserControl._CodigoEntidad;
            _CodigoBanco = loUserControl._TipoImpresion == TipoImpresion.CartaPagareStandar ? loUserControl._CodigoBanco : "";
            _CodigoCarta = loUserControl._TipoImpresion == TipoImpresion.CartaPagareEntidad ? loUserControl._CodigoCarta : "";
            _Numero_Copias = loUserControl._Copias;
        }


        public override bool _Show_Print(int tnAbrirEn = 1)
        {
            return (_Documento is PagarePago) ? _Documento._Show_Print() : false;
        }


        public override DocPrint _Clonar(DocPrint toDocPrint)
        {
            toDocPrint =  base._Clonar(toDocPrint);

            toDocPrint._Numero_Copias = _Numero_Copias;

            if (toDocPrint is DocPrintPagarePago)
            {
                ((DocPrintPagarePago)toDocPrint)._FechaEmision = _FechaEmision;
                ((DocPrintPagarePago)toDocPrint)._CodigoEntidad = _CodigoEntidad;
                ((DocPrintPagarePago)toDocPrint)._CodigoBanco = _CodigoBanco;
                ((DocPrintPagarePago)toDocPrint)._CodigoCarta = _CodigoCarta;
                ((DocPrintPagarePago)toDocPrint)._TipoImpresion = _TipoImpresion;
                ((DocPrintPagarePago)toDocPrint)._ShowInfoFOX = _ShowInfoFOX;
            }

            return toDocPrint;
        }

        public override bool _Print()
        {
            DataRow loRow;
            Boolean lbOk = true;
            PagarePago loPagarePago;

            loPagarePago = (PagarePago)this._Documento;

            switch (this._TipoImpresion)
            {
                case TipoImpresion.PagareEntidad:

                    loRow = _GetEntidad(_CodigoEntidad);
                    lbOk = _PrintPagareEntidad(loPagarePago, Convert.ToBoolean(loRow["TIPO_IMP_PAGARE"]));
                    break;

                case TipoImpresion.CartaPagareStandar:

                    lbOk = _PrintCartaPagareStandar(loPagarePago, Convert.ToBoolean(EW_GLOBAL._Empresa._TipoImpresionPagare));
                    break;

                case TipoImpresion.CartaPagareEntidad:

                    
                    Report loReport;
                    loReport = _Report;
                    
                    if(_Carta._TipoCarta == Mail500.TipoCarta.SageReports)
                    {
                        lbOk = _PrintCartaPagareEntidad(loPagarePago, true);
                    }
                    else
                    {
                        if (_Carta.IsFOXFile())
                        {
                            //lbOk = _PrintCartaPagareEntidad(loPagarePago, false);

                            _ErrorMessage = "Revise la configuración de la carta, el fichero indicado no es válido.";
                            lbOk = false;
                        }
                        else if (_Carta.IsFile())
                        {
                            if (_Carta.IsValidToDirectPrint())
                            {
                                _Carta._DocPrint.Printer = _Printer;
                                _Carta._DocPrint.NumCopies = (Int16)_Numero_Copias;
                                lbOk = _Carta._DocPrint.Print();
                            }
                            else
                            {
                                _ErrorMessage = "Revise la configuración de la carta, el fichero indicado no es válido.";
                                lbOk = false;
                            }
                        }
                        else
                        {
                            lbOk = _PrintCartaPagareStandar(loPagarePago, Convert.ToBoolean(EW_GLOBAL._Empresa._TipoImpresionPagare));
                        }
                    }
                   
                    break;

            }

            return lbOk;
        }

        public override Report _CrearReport()
        {
            Report loReport;

            loReport = base._CrearReport();
            loReport._TableName = this._TipoImpresion == TipoImpresion.PagareEntidad ? "PAGARE" : "PREVISIONES";

            return loReport;
        }

        protected override void _Configurar_obtencion_filtros(ref Dictionary<string, object> toDiccionario)
        {
            toDiccionario.Add("EsCheque", this._TipoImpresion == TipoImpresion.PagareEntidad);
            toDiccionario.Add("FechaEmision", _FechaEmision);
            toDiccionario.Add("CodigoBanco", _CodigoBanco);
            toDiccionario.Add("CodigoEntidad", _CodigoEntidad); 
        }

        private Boolean _PrintCartaPagareEntidad(PagarePago toPagarePago, Boolean tbImprimirNet = true)
        {
            return _PrintNET();

            //if (tbImprimirNet)
            //{
            //    return _PrintNET();
            //}
            //else
            //{
            //    //_ShowInfo();
            //    //return _PrintCartaPagareEntidadFOX(toPagarePago);
            //}
        }

        public void _ShowInfo(Boolean tlShow = false)
        {
            String lcMessage, lcTipo;

            if (_ShowInfoFOX || tlShow)
            {
                lcTipo = _Exportar ? "exportación" : "impresión";
                lcMessage = String.Format("Se ha detectado que la {1} de pagarés está configurada con un formato de impresión antiguo (FRX), que dejará de estar disponible a partir de la versión 50.7720.0 del 24/03/21.{0}{0}Será necesario revisar si los nuevos formatos se adaptan o será necesario algún ajuste adicional.{0}{0}", Environment.NewLine, lcTipo);

                if (_Exportar) lcMessage = String.Format("La exportación no esta disponible con un formato de impresión antiguo (FRX), estos pagarés se imprimirán.{0}{0}", Environment.NewLine);

                switch (_TipoImpresion)
                {
                    case TipoImpresion.CartaPagareEntidad:
                        lcMessage += "Puede cambiar al nuevo formato de impresión (REPORT) desde la pantalla de “Configuración de Empresa” > opción “Impresión” > pestaña “Contabilidad”.";
                        break;
                    default:
                        lcMessage += "Se recomienda cambiar la configuración al nuevo formato de impresión (REPORT) antes de esa fecha.";
                        break;
                }

                FUNCTIONS._MessageBox(lcMessage, MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1, DialogResult.OK);
            }
            _bPrintedByFox = true;
        }

        private Boolean _PrintCartaPagareStandar(PagarePago toPagarePago, Boolean tbImprimirNet = true)
        {
            return _PrintNET();

            //if (tbImprimirNet)
            //{
            //    return _PrintNET();
            //}
            //else
            //{
            //    _ShowInfo();
            //    return _PrintCartaPagareStandarFOX(toPagarePago);
            //}
        }

        private Boolean _PrintPagareEntidad(PagarePago toPagarePago, Boolean tbImprimirNet = true)
        {

            return _PrintNET();

            //if (tbImprimirNet)
            //{
            //    return _PrintNET();
            //}
            //else
            //{
            //    //_ShowInfo();
            //    //return _PrintPagareEntidadFOX(toPagarePago);
            //}
        }

        private bool _PrintCartaPagareEntidadFOX(PagarePago toPagarePago)
        {
            string lcRetorno = "";
            object[] loParametros;

            // Impresión utilizando report de carta pagaré declarado en la entidad del mantenimiento de entidades financieras. 
            loParametros = new object[7]
            {
                toPagarePago._Empresa,
                toPagarePago._Banco,
                toPagarePago._Pagare,
                this._FechaEmision,
                this._CodigoCarta,
                this._Printer,
                this._Numero_Copias
            };

            lcRetorno = NETVFP._Ejecutar_Funcion_VFP("IMPRIMIR_PAGAREPAGO_REPORT_CARTAENTIDAD_NET", loParametros);

            return true;
        }

        private bool _PrintCartaPagareStandarFOX(PagarePago toPagarePago)
        {
            string lcRetorno = "";
            object[] loParametros;

            // Impresión utilizando report de carta standar pagaré declarado en mantenimiento de empresa.
            loParametros = new object[7]
            {
                toPagarePago._Empresa,
                toPagarePago._Banco,
                toPagarePago._Pagare,
                this._FechaEmision,
                this._CodigoBanco,
                this._Printer,
                this._Numero_Copias
            };

            lcRetorno = NETVFP._Ejecutar_Funcion_VFP("IMPRIMIR_PAGAREPAGO_REPORT_CARTASTANDAR_NET", loParametros);

            return true;
        }

        private bool _PrintPagareEntidadFOX(PagarePago toPagarePago)
        {
            string lcRetorno = "";
            object[] loParametros;

            loParametros = new object[7]
            {
                toPagarePago._Empresa,
                toPagarePago._Banco,
                toPagarePago._Pagare,
                this._FechaEmision,
                this._CodigoEntidad,
                this._Printer,
                this._Numero_Copias
            };

            lcRetorno = NETVFP._Ejecutar_Funcion_VFP("IMPRIMIR_PAGAREPAGO_REPORT_PAGAREENTIDAD_NET", loParametros);

            return true;
        }

        protected override String _GetReportName()
        {
            String lcReportName = "";
            
            switch (this._TipoImpresion)
            {
                case TipoImpresion.PagareEntidad:

                    DataRow loRow = _GetEntidad(_CodigoEntidad);
                    lcReportName = loRow is DataRow && Convert.ToBoolean(loRow["TIPO_IMP_PAGARE"]) ? Convert.ToString(loRow["informe"]).Trim() : _ReportBase;
                    break;

                case TipoImpresion.CartaPagareStandar:

                    lcReportName = Convert.ToBoolean(EW_GLOBAL._Empresa._TipoImpresionPagare) ?  EW_GLOBAL._Empresa._Pagare?.Trim() : _ReportBase;
                    break;

                case TipoImpresion.CartaPagareEntidad:

                    lcReportName = _Carta._Report;
                    break;
            }

            return String.IsNullOrEmpty(lcReportName.Trim()) ? _ReportBase : lcReportName;
        }

        private DataRow _GetEntidad(String tcCodigoEntidad)
        {
           
            DataRow loRow = (from loRowEntidad in _Entidades.AsEnumerable()
                             where Convert.ToString(loRowEntidad["codigo"]) == tcCodigoEntidad
                             select loRowEntidad).FirstOrDefault();

            return loRow;
        }

        protected override void _ConfigureCustomPath(Report toReport)
        {
            BaseReportPath loReportPagarePath;

            switch (this._TipoImpresion)
            {
                case TipoImpresion.PagareEntidad:

                    loReportPagarePath = new ReportPagarePath();
                    break;

                case TipoImpresion.CartaPagareEntidad:
                default:

                    loReportPagarePath = new ReportPath();
                    break;
            }
            toReport._Path = loReportPagarePath;
        }

        public Boolean ValidaFicheroCarta()
        {
            if(_TipoImpresion == TipoImpresion.CartaPagareEntidad && _Carta._TipoCarta == Mail500.TipoCarta.Fichero)
            {
                if (!File.Exists(_Carta._PathFile))
                {
                    _ErrorMessage = _ErrorMessage = "Revise la configuración de la carta, el fichero indicado no existe.";
                    return false;
                }
                else if(_Carta.IsFOXFile())
                {
                    _ErrorMessage = _ErrorMessage = "Revise la configuración de la carta, el fichero indicado no es válido.";
                    return false;
                }
            }
            return true;
        }

        #endregion MÉTODOS PÚBLICOS OVERRIDE
    }
}