RemesaBancariaPago.cs

using System;
using System.Data;
using System.Windows.Forms;
using System.ComponentModel;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;

using sage.ew.global;
using sage.ew.db;
using sage.ew.interficies;
using sage.ew.contabilidad.Form;
using sage.ew.ewbase;
using sage.ew.docscompra;
using sage.ew.ewbase.Attributes;
using sage.ew.functions;
using sage.ew.netvfp;
using sage.ew.global.Diccionarios;
using sage.ew.functions.Clases;

namespace sage.ew.contabilidad
{
    public partial class RemesaBancariaPago : RemesaBancaria
    {
        #region PROPIEDADES PRIVADAS

        private RemesaBancariaDetallePrevis remesaBancariaDetallePrevis;


        #endregion PROPIEDADES PRIVADAS


        #region PROPIEDADES PÚBLICAS


        [FieldName("Tiporemesa")]
        [DisplayName("Tipo de esquema SEPA:")]
        [ReportProperty("EsquemaSepa", "", "Tipo de esquema SEPA::")]
        [DefaultValue(TipoEsquemaRemesaSepaPagos.Ninguno)]
        public TipoEsquemaRemesaSepaPagos _EsquemaSepa
        {
            get
            {
                if (!Enum.IsDefined(typeof(TipoEsquemaRemesaSepaPagos), this._nEsquemaSepa))
                {
                    this._nEsquemaSepa = (int)TipoEsquemaRemesaSepaPagos.Ninguno;
                }
                return (TipoEsquemaRemesaSepaPagos)this._nEsquemaSepa;
            }
            set
            {
                this._nEsquemaSepa = (int)value;
            }
        }


        [FieldName("Tiporemesa")]
        [DisplayName("Tipo de esquema SEPA:")]
        [ReportProperty("EsquemaSepa", "", "Tipo de esquema SEPA::")]
        [DefaultValue(0)]
        public int _nEsquemaSepa
        {
            get
            {
                return Convert.ToInt32(this._Campo(this.GetFieldName(nameof(this._nEsquemaSepa))));
            }
            set
            {
                int lnValor = value;

                if (!Enum.IsDefined(typeof(TipoEsquemaRemesaSepaPagos), lnValor))
                    lnValor = (int)TipoEsquemaRemesaSepaPagos.Ninguno;

                this._Campo(this.GetFieldName(nameof(this._nEsquemaSepa)), lnValor);

                // Actualizar el campo tipo (disco o impresora) según si es una remesa SEPA si o no
                this._Campo("TIPO", lnValor > 0 ? "D" : "I");

            }
        }


        [DefaultValue(false)]
        public bool _Sepa
        {
            get
            {
                return ((int)this._Campo(this.GetFieldName(nameof(this._EsquemaSepa)))) >= 1;
            }
        }


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

                return (DocPrintRemesaBancariaPago)_oDocPrint;
            }
            set { _oDocPrint = value; }
        }


        #endregion PROPIEDADES PÚBLICAS


        #region CONSTRUCTORES


        public RemesaBancariaPago() : base()
        {
            // Poner el código necesario en el método .Inicializar()

            return;
        }


        public RemesaBancariaPago(int numero) : base(numero)
        {
            // Poner el código necesario en el método .Inicializar()

            return;
        }


        #endregion CONSTRUCTORES


        #region MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE CLASE BASE 'DOCUMENTOBASE'


        protected override void Inicializar()
        {
            this._TipoRemesaBancaria = TipoRemesaBancaria.Pago;

            // Asignamos las propiedades para el mantenimiento.
            //
            this._Clave = "EMPRESA,NUMERO";
            this._DataBase = "GESTION";
            this._Tabla = "REMESAPA";
            this._TituloMantenimiento = "Remesa bancaria de pago";
            this._TituloCabecera = "Remesa bancaria de pago";
            this._TituloMenu = "Remesa bancaria de pago";

            this._Pantalla = "REM_PAGO";
            this._FormManteBaseType = typeof(frmRemesaBancariaPago);

            // La remesa bancaria de pago actualmente (Julio 2019) solo puede ser de previsiones (no puede ser de pagarés), de entrada hacemos que la 
            // propiedad protected de 'detalleDocumento' de la clase base 'DocumentoBase' la cree de tipo detalles de previsiones de pago.
            //
            // Pensar que por compatibilidad con remesa de cobro donde se pueden crear remesas de dos tipos (previsiones o pagarés), aquí en remesa de 
            // pago se utilizará el mismo sistema de ManteTRels en previsión de que algún día puedan pedir hacer remesas de pago de pagarés.
            // 
            // Al igual que en remesa de cobro, los objetos reales ManteTRel sobre los que trabajará la remesa bancaria de pago no será este objeto 
            // ManteTRel apuntado inicialmente por 'detalleDocumento' y que crea el constructor de la clase base 'DocumentoBase' (lo crea más adelante 
            // en la ejecución), sino que se crea (más abajo en este método) un ManteTRels de previsiones (en remesa de cobros se crean dos, el de 
            // previsiones y el de pagarés), y se hará que la propiedad 'detalleDocumento' de la clase base 'DocumentoBase' apunte a este ManteTRel de 
            // previsiones que hemos creado, prescindiendo del objeto ManteTRel al que inicialmente lo hace apuntar el constructor de 'DocumentoBase' 
            // del cual se descarta su uso.
            //
            // Si en un futuro se implementan remesas de pago de pagarés, al igual que en remesa de cobros, se creará un segundo ManteTRel de pagarés, 
            // y se hará que la propiedad 'detalleDocumento' apunte a un ManteTRel o a otro, en función del tipo de documento de la remesa.

            this._DetalleDocumentoType = typeof(RemesaBancariaDetallePrevis);
            this._TypeLinea = typeof(RemesaBancariaDetallePrevis.Linea);

            // Datos de la tabla contador para poder obtener un nuevo número de remesa de pago.
            //
            this._cBdTablaContadorRemesa = "GESTION";
            this._cTablaContadorRemesa = "EMPRESA";
            this._cCampoEmpresaTablaContadorRemesa = "CODIGO";
            this._cCampoContadorRemesa = "REMESAPA";

            // Creamos el mantetrel de previsiones de pago y hacemos apuntar la propiedad protected 'detalleDocumento' de la clase base 'DocumentoBase' 
            // al mantetrel de previsiones.
            // De esta forma todo el código de la clase base 'DocumentoBase' que haga uso de la propiedad protected 'detalleDocumento' o de la propiedad
            // pública _Detalle, continuará funcionando pues estará accediendo al ManteTRel de previsiones o al ManteTRel de pagarés, en función del tipo
            // documento de remesa.
            //
            // Se mantiene el mismo sistema de creación de ManteTRel que en remesa bancaria de cobro, en previsión de si algún día nos piden por hacer
            // remesas de pago de pagarés, con la salvedad de que aquí solo creamos de momento uno, el de previsiones (no creamos el de pagares), y también
            // haremos apuntar la propiedad protected 'detalleDocumento' de la clase base 'DocumentoBase' a este ManteTRel aunque de momento no haya
            // ningún otro.
            //
            this.remesaBancariaDetallePrevis = new RemesaBancariaDetallePrevis();
            this._AddManteTRel(remesaBancariaDetallePrevis);

            this._ReportTitlePreview = this._TituloMantenimiento;
            this._ReportBase = "DocumentoRemBancPago";

            return;
        }


        #endregion MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE CLASE BASE 'DOCUMENTOBASE'


        #region MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE CLASE BASE 'REMESABANCARIA'


        protected override void apuntarARemesaTipoDocumento(TipoDocumentoRemesa teTipoDocumentoRemesa)
        {
            switch (teTipoDocumentoRemesa)
            {
                case TipoDocumentoRemesa.Previsiones:
                    this.detalleDocumento = this.remesaBancariaDetallePrevis;
                    this._DetalleDocumentoType = typeof(RemesaBancariaDetallePrevis);
                    this._TypeLinea = typeof(RemesaBancariaDetallePrevis.Linea);
                    break;

                case TipoDocumentoRemesa.Pagares:
                    // Dejamos esto preparado por si algún día piden hacer remesa bancaria de pago de pagarés (al igual que en remesa de cobro).
                    break;
            }
            return;
        }


        protected override List<string> obtenerListaAsis()
        {
            List<string> lstAsis = new List<string>();
            DataTable ldtAsisRelacs = new DataTable(), ldtAsisPrevis = new DataTable();
            string lcSql = "", lcAsiRelac = "";
            bool llOk = false;

            // En este punto si estoy ejecutando este procedimiento es por que la remesa está contabilizada lo cual quiere decir que todas las previsiones
            // estan actualizadas en la bd. Puedo obtener los ASI,s de las previsiones accediendo directamente a la bd, en vez de ir mirando linea a linea
            // la previsión de cobro del mantetrel de lineas y haciendo el _Load() de cada objeto PrevisionCobro. Mucho más rápido así.
            //
            DB.SQLExec("select asi from " + DB.SQLDatabase("comunes", "previs") + " " +
                       "where empresa=" + DB.SQLString(this._cEmpresa) + " and remesa=" + DB.SQLString(this._Numero) + " " +
                       "and empresa!=" + DB.SQLString("") + " and factura!=" + DB.SQLString("") + " and proveedor!=" + DB.SQLString("") + " and " +
                       "asi!=" + DB.SQLString("") + " " +
                       "order by vencim", ref ldtAsisPrevis);

            string lcAsi = "";
            foreach (DataRow loRowPrevis in ldtAsisPrevis.Rows)
            {
                lcAsi = Convert.ToString(loRowPrevis["asi"]);
                if (!lstAsis.Contains(lcAsi))
                    lstAsis.Add(lcAsi);

                // Obtengo los posibles asientos relacionados con el ASI de la prevision (para obtener los asientos 400-401 que se generan
                // caso de asentar la remesa por vencimientos/proveedores y tener activado el OPCFLAG "ASENTAR REMESAS PAGO POR VTOS. MEDIANTE CUENTA DE EFECTOS"
                // WL_EFEC_REMP).
                // 
                lcSql = "select asi2 from " + DB.SQLDatabase("gestion", "asi_rel") + " " +
                        "where ejercicio=" + DB.SQLString(this._lcAny) + " and asi1=" + DB.SQLString(lcAsi) + " and asi2!=' '";
                llOk = DB.SQLExec(lcSql, ref ldtAsisRelacs);

                foreach (DataRow loRow in ldtAsisRelacs.Rows)
                {
                    lcAsiRelac = Convert.ToString(loRow["asi2"]);
                    if (!lstAsis.Contains(lcAsiRelac))
                        lstAsis.Add(lcAsiRelac);
                }
            }

            return lstAsis;
        }


        protected override bool generarAsientosPorConcepto(AsiRemAgruparPor teAsiRemAgruparPor, AsiRemCtaEfecDesc teAsiRemCtaEfecDesc, string tcCuentaContableBanco, string tcCuentaContablaEfecDescBanco, Dictionary<string, List<string>> toDicAsiEfecRemCta, ref string tcAsiRemesa)
        {
            bool llOk = false;
            DateTime ldtVencimConcepto, ldtVencimPrevision;
            int lnPeriodo, lnOrden, lnPendiente;
            string lcFactura = "", lcProveedor="", lcCuentaLinea = "", lcAsi = "";
            decimal lnImporteLinea = 0;
            List<Tuple<int, string, int, int, int, string >> lstPrevisAsientoVencim = new List<Tuple<int, string, int, int, int, string>>();


            // Si está activado el opcflag de "ASENTAR REMESAS PAGOPOR VTOS. MEDIANTE CUENTA DE EFECTOS" en vez de utilzarse cuentas 400 en los
            // asientos de vencimiento o proveedor se utilizan cuentas 401, y además se hacen unos asientos adicionales para cada cuenta proveedor.
            //
            bool llEfecRemP = this._lEfecRemp && !string.IsNullOrWhiteSpace(this._cEfecRemP);

            // Si no llega instanciado un valor en tcAsiRemesa quiere decir que el ASI que hemos de devolver lo hemos
            // de obtener dentro de este método y corresponderá al ASI del ultim asiento que generemos (al igual que hace 
            // FOX)
            //
            bool llObtenerAsiUltimoConcepto = string.IsNullOrWhiteSpace(tcAsiRemesa);

            // Agrupo las previsiones de la remesa por vencimiento o por proveedor
            //
            var previsionesPorVencim = from p in this.remesaBancariaDetallePrevis._Items
                                        where p.Fila_Plena()
                                        orderby p._Vencim
                                        group p by p._Vencim into g
                                        select new
                                        {
                                            concepto = Convert.ToString(g.Key),
                                            importe = g.Sum(x => x._Importe),
                                            vencim = g.Max(x => x._Vencim),
                                            previsiones = g.ToList(),
                                            
                                        };

            // Si se asienta por proveedor la fecha de asiento será la máxima fecha de vencimiento para ese proveedor.
            //
            var previsionesPorProveed = from p in this.remesaBancariaDetallePrevis._Items
                                        where p.Fila_Plena()
                                        orderby p._Cuenta
                                        group p by p._Cuenta into g
                                        select new
                                        {
                                            concepto = g.Key,
                                            importe = g.Sum(x => x._Importe),
                                            vencim = g.Min(x => x._Vencim),
                                            previsiones = g.ToList()
                                        };

            // Para cada vencimiento o para cada proveedor hago asiento.
            //
            var conceptos = (teAsiRemAgruparPor == AsiRemAgruparPor.Vencimiento ? previsionesPorVencim : previsionesPorProveed);

            foreach (var concepto in conceptos)
            {
                // Si se asienta por vencimientos, la fecha de asiento de cada vencimiento será la fecha de vencimiento.
                // Si se asienta por proveedor, la fecha de asiento de cada proveedor será la fecha máxima de vencimiento de los
                // vencimientos del proveedor.
                //
                ldtVencimConcepto = Convert.ToDateTime(concepto.vencim);

                // Creamos el asiento para el vencimiento, o para el proveedor.
                //
                Asientos loAsiento = this.asientoNuevo(ldtVencimConcepto);

                // La cuenta que pondré en esta partida difiere según si utilizo cuenta de efectos descontados o no.
                //

                this.asientoNuevaLinea(loAsiento, teAsiRemCtaEfecDesc == AsiRemCtaEfecDesc.NoUtilizarEfecD ? tcCuentaContableBanco : tcCuentaContablaEfecDescBanco, "REMESA DE RECIBOS Nº " + this._Numero.Trim(), 1, "H", concepto.importe);

                lstPrevisAsientoVencim.Clear();
                foreach (RemesaBancariaDetallePrevis.Linea loLinea in concepto.previsiones)
                {
                    lnPeriodo = loLinea._Periodo;
                    lcFactura = loLinea._Factura;
                    lcProveedor = loLinea._Cuenta;
                    lnOrden = loLinea._Orden;
                    lnPendiente = loLinea._Pendiente;
                    lnImporteLinea = loLinea._Importe;
                    ldtVencimPrevision = Convert.ToDateTime(loLinea._Vencim);

                    if (!llEfecRemP)
                    {
                        lcCuentaLinea = loLinea._Cuenta;
                    }
                    else
                    {
                        // Obtener la cuenta de efectos respectiva a la linea del cliente de la previsión.
                        //
                        lcCuentaLinea = this.cuentaEfecto(loLinea._Cuenta);
                    }

                    this.asientoNuevaLinea(loAsiento, lcCuentaLinea, "REMESA Nº " + this._Numero.Trim() + " FRA Nº " + lcFactura.ToUpper().Trim() + "/" + lnOrden.ToString().Trim() + " " + ldtVencimPrevision.ToString(EW_GLOBAL._CustomFormatDate), 1, "D", lnImporteLinea);

                    lstPrevisAsientoVencim.Add(new Tuple<int, string, int, int, int, string >(lnPeriodo, lcFactura, lnOrden, 0, lnPendiente, lcProveedor));
                }


                // Grabo el asiento.
                //
                llOk = loAsiento._Save();
                if (!llOk)
                {
                    // Si algún asiento no se genera correctamente abandono sin esperar a causar más estragos.
                    //
                    this._Error_Message = loAsiento._Mensaje_Error;
                    return false;
                }
                else
                {
                    // Para el caso de utilizar cuenta de efectos descontados el ASI que se guarda en la cabecera
                    // de la remesa ya es el del primer asiento general que se generó antes de entrar en el recorrido 
                    // por las previsiones.
                    //
                    // Para el caso de no utilizar cuenta de efectos descontados el ASI será el del primer asiento
                    // por vencimiento que se genere en el recorrido por las previsiones.

                    lcAsi = loAsiento._Asi_Primera_Linea();

                    if (llEfecRemP)
                    {
                        // Guardar la relación de este asiento con el asiento 400-401, de esta forma si desasientan la remesa, a partir del 
                        // asiento de pago de la prevision se puede acceder al asiento 400-401 y borrarlo también. 
                        // 
                        // En GESTION!ASI_REL se genera un registro para cada asiento 400-401 generado, lo suficiente para poder hacer lo descrito anteriormente 
                        // si desasientan la remesa.
                        //
                        this.insertarRegistroAsiRela(loAsiento, toDicAsiEfecRemCta);
                    }

                    // Nos quedamos con el ASI de cada asiento que vamos generando, así cuando abandonemos el métodoe necesariamente
                    // tcAsiRemesa será el del último asiento por concepto generado, que es lo que buscamos.
                    //
                    if (llObtenerAsiUltimoConcepto)
                        tcAsiRemesa = lcAsi;

                    // Actualizar campos de pago en previsiones de pago de la remesa que han intervenido en este asiento en particular.
                    //
                    llOk = this.actualizarCamposCobroPagoEnPrevisiones(lcAsi, ldtVencimConcepto, tcCuentaContableBanco, null, lstPrevisAsientoVencim);
                    if (!llOk)
                        break;
                }
            }

            return llOk;
        }


        protected override bool actualizarCamposCobroPagoEnPrevisiones(string tcAsi, DateTime tdFechaAsiento, string tcCuentaContableBanco, DateTime? tdFechaDescuento = null, List<Tuple<int, string, int, int, int, string>> tlstPrevisiones = null)
        {
            bool llActuOk = true;
            string lcEmpresa = "", lcFactura = "", lcProveedor="";
            int lnPeriodo, lnOrden = 0, lnPendiente = 0;

            try
            {
                if (tlstPrevisiones == null)
                {
                    // Actualizar campos pago en todas las previsiones de la remesa.
                    //
                    foreach (RemesaBancariaPago.RemesaBancariaDetallePrevis.Linea loLinea in this.remesaBancariaDetallePrevis)
                    {
                        if (loLinea.Fila_Plena())
                        {
                            lcEmpresa = loLinea._Empresa;
                            lnPeriodo = loLinea._Periodo;
                            lcFactura = loLinea._Factura;
                            lcProveedor = loLinea._Cuenta;
                            lnOrden = loLinea._Orden;
                            lnPendiente = Convert.ToInt32(loLinea._Pendiente);

                            llActuOk = this.actualizarCamposPagoEnPrevis(lcEmpresa, lnPeriodo, lcProveedor, lcFactura, lnOrden,  lnPendiente, tcAsi, tdFechaAsiento, tcCuentaContableBanco);
                            if (!llActuOk)
                            {
                                // El mensaje de error ya fue rellenado por la llamada anterior.
                                break;
                            }
                        }
                    }
                }
                else
                {
                    // Actualizar campos de cobro en las previsiones de cobro recibidas en el parámetro tlstPrevisiones
                    //

                    // Diccionario que vamos a utilizar para buscar previsiones en la remesa.
                    //
                    Dictionary<string, object> loDicBusqueda = new Dictionary<string, object>();
                    loDicBusqueda.Add("_Periodo", 0);
                    loDicBusqueda.Add("_Cuenta", "");
                    loDicBusqueda.Add("_Factura", "");
                    loDicBusqueda.Add("_Orden", 0);
                    loDicBusqueda.Add("_Pendiente", 0);

                    for (int ln = 0; ln <= tlstPrevisiones.Count - 1; ln++)
                    {
                        lnPeriodo = tlstPrevisiones[ln].Item1;
                        lcFactura = tlstPrevisiones[ln].Item2;
                        lnOrden = tlstPrevisiones[ln].Item3;
                        lnPendiente = tlstPrevisiones[ln].Item5;
                        lcProveedor = tlstPrevisiones[ln].Item6;

                        // Busco si la previsión está ya en la remesa.
                        //
                        loDicBusqueda["_Periodo"] = lnPeriodo;
                        loDicBusqueda["_Cuenta"] = lcProveedor;
                        loDicBusqueda["_Factura"] = lcFactura;
                        loDicBusqueda["_Orden"] = lnOrden;
                        loDicBusqueda["_Pendiente"] = lnPendiente;

                        RemesaBancariaDetallePrevis.Linea loLinea = this.remesaBancariaDetallePrevis._GetItem(loDicBusqueda);
                        if (loLinea != null)
                        {
                            llActuOk = this.actualizarCamposPagoEnPrevis(loLinea._Empresa, loLinea._Periodo, loLinea._Cuenta, loLinea._Factura, loLinea._Orden, loLinea._Pendiente, tcAsi, tdFechaAsiento, tcCuentaContableBanco);
                            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;
        }


        #endregion MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE CLASE BASE 'REMESABANCARIA'


        #region MÉTODOS PÚBLICOS OVERRIDE SOBREESCRITOS DE CLASE BASE 'DOCUMENTOBASE'


        public override void _Show()
        {
            // Lo asocio a la propiedad _FormMante de negocio pues así se sabe internamente
            // que negocio está ligado a visual.
            //
            this._FormMante = new frmRemesaBancariaPago(this);
            this._FormMante._Show();

            if (!string.IsNullOrWhiteSpace(this._Codigo))
            {
                if (this._FormMante != null)
                    this._FormMante._Cargar_Documento();
            }

            return;
        }


        #endregion MÉTODOS PÚBLICOS OVERRIDE SOBREESCRITOS DE CLASE BASE 'DOCUMENTOBASE'


        #region MÉTODOS PÚBLICOS OVERRIDE SOBREESCRITOS DE CLASE BASE 'REMESABANCARIA'


        public override bool _Contabilizar(Dictionary<string, object> toDicParametros)
        {
            bool llOk = true;
            this._Error_Message = "";

            // Captación de parámetros.
            //
            DateTime tdFechaAsiento = DateTime.Today;
            FormaContabilRemesaPago teFormaContabil = contabilidad.FormaContabilRemesaPago.AsientoUnico;
            object objetoAuxi;

            if (toDicParametros.TryGetValue("fechaasiento", out objetoAuxi))
                tdFechaAsiento = Convert.ToDateTime(objetoAuxi);

            if (toDicParametros.TryGetValue("formacontabil", out objetoAuxi))
                teFormaContabil = (FormaContabilRemesaPago)Enum.Parse(typeof(FormaContabilRemesaPago), objetoAuxi.ToString());


            try
            {
                // En función de la forma de contabilización llamamos al método respectivo.
                //
                switch (teFormaContabil)
                {
                    case FormaContabilRemesaPago.AsientoUnico:
                        // Generamos asiento único de remesa (572 contra 400)
                        //
                        llOk = this.contabRemPreviAsientoUnico(tdFechaAsiento);
                        break;

                    case FormaContabilRemesaPago.AsientoPorVencimNoEfecDto:
                        // Generamos un asiento para cada vencimiento en el cual se incluirán todas las previsiones con ese vencimiento.
                        // El asiento será del tipo 572 a 400.

                        // Si está activado el opcflag de "ASENTAR REMESAS PAGO POR VTOS. MEDIANTE CUENTA DE EFECTOS" en los asientos de 
                        // los vencimientos en vez de utilizarse las cuentas 400 se utilizan las cuentas 401 y se hace adicionalmente un 
                        // asiento para cada proveedor del tipo (400 a 401).
                        //
                        llOk = this.contabRemPreviAsientoPorConcepto(tdFechaAsiento, AsiRemAgruparPor.Vencimiento, AsiRemCtaEfecDesc.NoUtilizarEfecD);
                        break;

                    case FormaContabilRemesaPago.AsientoPorVencimEfecDto:
                        // Se genera un asiento 5208 a 5720 por el importe total de la remesa.
                        //
                        // Se genera un asiento para cada vencimiento en el cual se incluirán todas las previsiones con ese vencimiento.
                        // El asiento será del tipo 5208 a 400.
                        //
                        // Si está activado el opcflag de "ASENTAR REMESAS PAGO POR VTOS. MEDIANTE CUENTA DE EFECTOS" en los asientos de 
                        // los vencimientos en vez de utilizarse las cuentas 400 se utilizan las cuentas 401 y se hace adicionalmente un 
                        // asiento para cada proveedor del tipo (400 a 401).
                        //
                        llOk = this.contabRemPreviAsientoPorConcepto(tdFechaAsiento, AsiRemAgruparPor.Vencimiento, AsiRemCtaEfecDesc.UtilizarEfecD);
                        break;

                    case FormaContabilRemesaPago.AsientoPorProveedNoEfecDto:
                        // Generamos un asiento para cada proveedor en el cual se incluirán todas las previsiones de ese proveedor.
                        // El asiento será del tipo 572 a 400.

                        // Si está activado el opcflag de "ASENTAR REMESAS PAGO POR VTOS. MEDIANTE CUENTA DE EFECTOS" en los asientos de 
                        // los proveedores en vez de utilizarse las cuentas 400 se utilizan las cuentas 401 y se hace adicionalmente un 
                        // asiento para cada proveedor del tipo (400 a 401).
                        //
                        llOk = this.contabRemPreviAsientoPorConcepto(tdFechaAsiento, AsiRemAgruparPor.Cuenta, AsiRemCtaEfecDesc.NoUtilizarEfecD);
                        break;

                    case FormaContabilRemesaPago.AsientoPorProveedEfecDto:
                        // Se genera un asiento 5208 a 5720 por el importe total de la remesa.
                        //
                        // Se genera un asiento para cada proveedor en el cual se incluirán todas las previsiones de ese proveedor.
                        // El asiento será del tipo 5208 a 400.
                        //
                        // Si está activado el opcflag de "ASENTAR REMESAS PAGO POR VTOS. MEDIANTE CUENTA DE EFECTOS" en los asientos de 
                        // los proveedores en vez de utilizarse las cuentas 400 se utilizan las cuentas 401 y se hace adicionalmente un 
                        // asiento para cada proveedor del tipo (400 a 401).
                        //
                        llOk = this.contabRemPreviAsientoPorConcepto(tdFechaAsiento, AsiRemAgruparPor.Cuenta, AsiRemCtaEfecDesc.UtilizarEfecD);
                        break;
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }


            if (!llOk && string.IsNullOrWhiteSpace(this._Error_Message))
                this._Error_Message = "No se ha podido contabilizar la remesa.";

            return llOk;
        }


        public override bool _DesContabilizar()
        {
            bool llOkDescontabilizar = false, llOkVaciarCampos = false, llOkSaveRemesa = false;

            this._Error_Message = "";

            // La clase PrevisionPago en su método ._Descontabilizar() si detecta que el asiento del pago de la previsión afecta a más de una previsión
            // de pago no elimina el asiento (como es lógico), motivo por el cual no puedo utilizar aquí ese método de la clase PrevisionPago.
            //

            try
            {
                llOkVaciarCampos = this.vaciarCamposPagoEnPrevisiones();

                if (!string.IsNullOrWhiteSpace(this._Asi))
                {
                    Asientos loAsiento = new Asientos(this._Asi);
                    loAsiento._Delete();
                    loAsiento = null;
                }

                this._Asi = "";
                this._Asentada = false;
                
                this._lDescontabilizando = true;

                llOkSaveRemesa = this._Save();

                this._lDescontabilizando = false;

                if (!llOkSaveRemesa)
                {
                    if (string.IsNullOrWhiteSpace(this._Error_Message))
                        this._Error_Message = "No se pudieron actualizar los cambios en la remesa.";
                }

                llOkDescontabilizar = llOkVaciarCampos && llOkSaveRemesa;
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOkDescontabilizar = false;
            }

            return llOkDescontabilizar;
        }


        public override bool _Comprobaciones_GenerarSepa()
        {
            this._Error_Message = "";

            bool llOk = base._Comprobaciones_GenerarSepa();
            if (!llOk)
                return false;

            // Control de tipo de esquema SEPA no seleccionado.
            //
            if (this._EsquemaSepa == TipoEsquemaRemesaSepaPagos.Ninguno)
            {
                _Error_Message = "No ha seleccionado el tipo de esquema SEPA para la generación del fichero.";
                return false;
            }

            return true;
        }


        #endregion MÉTODOS PÚBLICOS OVERRIDE SOBREESCRITOS DE CLASE BASE 'REMESABANCARIA'


        #region MÉTODOS PÚBLICOS


        public bool _AddPrevisiones(DataRow[] taDataRowsPrevis, out DataRow[] toDataRowsPrevisNoAnadidas, bool tlSave = false)
        {
            bool llOk = true;
            this._Error_Message = "";

            // En esta lista guardaremos las previsiones no añadidas.
            //
            toDataRowsPrevisNoAnadidas = new DataRow[0];

            try
            {
                if (string.IsNullOrWhiteSpace(this._Numero))
                {
                    this._Error_Message = "No está cargada ninguna remesa a la cual añadir previsiones.";
                    return false;
                }

                if (this._TipoDocumentoRemesa != TipoDocumentoRemesa.Previsiones)
                {
                    this._Error_Message = "No se permite añadir previsiones a una remesa que no es de tipo documento previsiones.";
                    return false;
                }

                // Añadir las previsiones de pago a la remesa.
                //
                llOk = this.addPrevisiones(taDataRowsPrevis, out toDataRowsPrevisNoAnadidas);
                if (!llOk)
                    return false;

                if (tlSave)
                {
                    llOk = this._Save();

                    if (!llOk)
                    {
                        if (string.IsNullOrWhiteSpace(this._Error_Save))
                            this._Error_Message = this._Error_Save;

                        if (string.IsNullOrWhiteSpace(this._Error_Message))
                            this._Error_Message = "No se han podido añadir las previsiones a la remesa correctamente.";
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }
            return llOk;
        }


        public bool _AddPrevisiones(List<PrevisionPago> toLstPrevis, out List<PrevisionPago> tolstPrevisNoAnadidas, bool tlSave = false)
        {
            bool llOk = true;
            this._Error_Message = "";

            // En esta lista guardaremos las previsiones no añadidas.
            //
            tolstPrevisNoAnadidas = new List<PrevisionPago>();

            try
            {
                if (string.IsNullOrWhiteSpace(this._Numero))
                {
                    this._Error_Message = "No está cargada ninguna remesa a la cual añadir previsiones.";
                    return false;
                }

                if (this._TipoDocumentoRemesa != TipoDocumentoRemesa.Previsiones)
                {
                    this._Error_Message = "No se permite añadir previsiones a una remesa que no es de tipo documento previsiones.";
                    return false;
                }

                // Añadir las previsiones de pago a la remesa.
                //
                llOk = this.addPrevisiones(toLstPrevis, out tolstPrevisNoAnadidas);
                if (!llOk)
                    return false;

                if (tlSave)
                {
                    llOk = this._Save();

                    if (!llOk)
                    {
                        if (string.IsNullOrWhiteSpace(this._Error_Save))
                            this._Error_Message = this._Error_Save;

                        if (string.IsNullOrWhiteSpace(this._Error_Message))
                            this._Error_Message = "No se han podido añadir las previsiones a la remesa correctamente.";
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }
            return llOk;
        }


        public bool _CrearRemesaPrevisiones(ParamCreacionRemesaPago loParamCreaCnf, DataRow[] taDataRowsPrevis, out DataRow[] toDataRowsPrevisNoAnadidas, bool tlSave = true)
        {
            bool llOk = true;
            this._Error_Message = "";

            // En esta lista guardaremos las previsiones no añadidas.
            //
            toDataRowsPrevisNoAnadidas = new DataRow[0];

            try
            {
                if (llOk)
                {
                    llOk = this.crearCabeceraRemesa(loParamCreaCnf);
                    if (!llOk)
                        return false;
                }

                // Añadir las previsiones de pago a la remesa.
                //
                llOk = this.addPrevisiones(taDataRowsPrevis, out toDataRowsPrevisNoAnadidas);
                if (!llOk)
                    return false;

                if (tlSave)
                {
                    llOk = this._Save();
                    if (!llOk)
                    {
                        if (string.IsNullOrWhiteSpace(this._Error_Save))
                            this._Error_Message = this._Error_Save;

                        if (string.IsNullOrWhiteSpace(this._Error_Message))
                            this._Error_Message = "No se han podido crear la remesa de pago correctamente.";
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            return llOk;
        }


        public bool _CrearRemesaPrevisiones(ParamCreacionRemesaPago loParamCreaCnf, List<PrevisionPago> toLstPrevis, out List<PrevisionPago> tolstPrevisNoAnadidas, bool tlSave=true)
        {
            bool llOk = true;
            this._Error_Message = "";

            // En esta lista guardaremos las previsiones no añadidas.
            //
            tolstPrevisNoAnadidas = new List<PrevisionPago>();

            try
            {
                if (llOk)
                {
                    llOk = this.crearCabeceraRemesa(loParamCreaCnf);
                    if (!llOk)
                        return false;
                }

                // Añadir las previsiones de pago a la remesa.
                //
                llOk = this.addPrevisiones(toLstPrevis, out tolstPrevisNoAnadidas);
                if (!llOk)
                    return false;

                if (tlSave)
                {
                    llOk = this._Save();
                    if (!llOk)
                    {
                        if (string.IsNullOrWhiteSpace(this._Error_Save))
                            this._Error_Message = this._Error_Save;

                        if (string.IsNullOrWhiteSpace(this._Error_Message))
                            this._Error_Message = "No se han podido crear la remesa de pago correctamente.";
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            return llOk;
        }


        public void _Set_GridDetalleRemesaPrevisiones(objetos.UserControls.Mantegrid mantegrid)
        {
            this.remesaBancariaDetallePrevis._Grid = mantegrid;

            sage.ew.objetos.ewgrid loGrid = ((sage.ew.objetos.UserControls.Mantegrid)this.remesaBancariaDetallePrevis._Grid)._Grid;

            this.ajustesVisualesGrid(loGrid);

            return;
        }


        public new void _ShowDialog()
        {
            // Crear la instancia del formulario y asignar objetos
            this._FormMante = new frmRemesaBancariaPago(this);

            // En este caso, primero cargamos el documento y luego lo mostramos modal
            if (!string.IsNullOrWhiteSpace(this._Codigo))
            {
                if (this._FormMante != null)
                    this._FormMante._CargarDocumento();
            }

            // Mostrar el form
            ((formul.FormBaseDocumento)_FormMante).ShowDialog();
        }


        #endregion MÉTODOS PÚBLICOS


        #region MÉTODOS PRIVADOS


        #region MÉTODOS PRIVADOS PARA CONTABILIZACION DE REMESAS DE PREVISIONES DE PAGO


        private bool actualizarCamposPagoEnPrevis(string tcEmpresa, int tnPeriodo, string tcProveedor, string tcFactura, int tnOrden, int tnPendiente, string tcAsi, DateTime tdFechaAsiento, string tcCuentaContableBanco)
        {
            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._Asiento = true;
                    loPrevision._Fecha_Pago = tdFechaAsiento;
                    loPrevision._Banco = tcCuentaContableBanco;
                    loPrevision._Asi = tcAsi;
                    loPrevision._Pagada = "S";

                    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();
                    }
                    else
                    {
                        // Esto ya no hace falta hacerlo, lo hace la clase PrevisionPago al hacer el _Save() en las lineas anteriores, 
                        // si dejamos este código aquí duplicaba el asiento de traspaso de saldos por que un asiento lo hacía el _Save() y
                        // el otro lo hacía aquí.
                        // CCR205142
                        // Comento el código
                        //if (loPrevision._Recc)
                        //{
                        //    // Si la previsión es de RECC llamamos a FOX para que haga el proceso respectivo.

                        //    // Preparamos los parámetros para actualizar el RECC
                        //    // LPARAMETERS tcEmpresa, tcProveedor, tcFactura, tnNumereb, tnPendiente, tdEmision, tnDoccargo, tcPeriodo, tcAsi,  tcOldAsi, lnDigitosFra, tnOldImporte
                        //    object[] loParametros = new object[11]
                        //            {
                        //                    tcEmpresa,
                        //                    tcProveedor,
                        //                    tcFactura,
                        //                    tnOrden,
                        //                    tnPendiente,
                        //                    loPrevision._Fecha_Emision,
                        //                    "", // DocCargo
                        //                    tnPeriodo,
                        //                    tcAsi,
                        //                    "",
                        //                    loPrevision._Importe
                        //             };

                        //    NETVFP._Ejecutar_Funcion_VFP("Modifica_Previs_Recc_Net", loParametros);
                        //}
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            return llOk;
        }


        private bool vaciarCamposPagoEnPrevisiones()
        {
            bool llActuOk = true, llOk = false;
            string lcEmpresa = "", lcFactura = "", lcProveedor="";
            int lnPeriodo, lnOrden = 0, lnPendiente = 0;

            try
            {
                // Actualizar campos pago en todas las previsiones de la remesa.
                //
                foreach (RemesaBancariaDetallePrevis.Linea loLinea in this.remesaBancariaDetallePrevis)
                {
                    if (loLinea.Fila_Plena())
                    {
                        lcEmpresa = loLinea._Empresa;
                        lnPeriodo = loLinea._Periodo;
                        lcProveedor = loLinea._Cuenta;
                        lcFactura = loLinea._Factura;
                        lnOrden = loLinea._Orden;
                        lnPendiente = loLinea._Pendiente;

                        llOk = this.vaciarCamposPagoEnPrevision(lcEmpresa, lnPeriodo, lcProveedor, lcFactura, lnOrden, lnPendiente);
                        if (!llOk)
                            llActuOk = false;
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llActuOk = false;
            }

            return llActuOk;
        }


        private bool vaciarCamposPagoEnPrevision(string tcEmpresa, int tnPeriodo, string tcProveedor, string tcFactura, int tnOrden, int tnPendiente)
        {
            bool llActuOk = true, llOk = false;
            string lcOldAsi = "";

            // Si está activado el opcflag de "ASENTAR REMESAS PAGO POR VTOS. MEDIANTE CUENTA DE EFECTOS" en vez de utilzarse cuentas 400 en los
            // asientos por vencimiento/proveedor se utilizan cuentas 401, y además se hacen unos asientos adicionales para cada cuenta proveedor.
            //
            bool llEfecRemP = this._lEfecRemp && !string.IsNullOrWhiteSpace(this._cEfecRemP);

            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)
                {
                    // Estos campos de pago de la previsión podrian estar ya vacios si se pasó ya por otra previsión en esta misma remesa que apuntaba al mismo 
                    // asiento de pago pues entonces ya se eliminó el asiento de pago y al hacerlo se desmarcaron todas las previsiones de pago 
                    // asociadas con el mismo ASI que el asiento eliminado.
                    //

                    lcOldAsi = loPrevision._Asi;

                    loPrevision._Asiento = false;
                    loPrevision._Fecha_Pago = null;
                    loPrevision._Asi = "";
                    loPrevision._Pagada = "N";

                    llOk = loPrevision._Save();

                    if (!llOk)
                    {
                        this._Error_Message = "No se pudieron vaciar los campos de pago en la previsión de pago Proveedor "+tcProveedor+" Factura " + tcFactura.Trim() + " Orden " + tnOrden.ToString();
                        llActuOk = false;
                    }

                    // Este ASI podría estar ya vacío por lo que se comentó más arriba.
                    //
                    if (!string.IsNullOrWhiteSpace(lcOldAsi))
                    {
                        Asientos loAsiento;
                        String lcEjerDB = DB.Ejercicio_EW;
                        DataTable loDt = _ObtenerEjerciciosAsi(new List<String>() { lcOldAsi });

                        if (loDt.Rows.Count > 0)
                        {
                            string lcEjer = Convert.ToString(loDt.Rows[0]["EJERCICIO"]);
                            functions.Clases.CambioEjercicio loEjer = new functions.Clases.CambioEjercicio();

                            if (lcEjer != lcEjerDB) loEjer._Cambiar(lcEjer);

                            loAsiento = new Asientos(lcOldAsi);
                            if (!loAsiento._Delete(false))
                            {
                                this._Error_Message = string.Format("No se pudo eliminar el asiento de pago correspondiente a la previsión de pago proveedor {0}, factura {1}, orden {2} y ejercicio {3} : {4}", tcProveedor, loPrevision._Factura.Trim(), loPrevision._Numereb.ToString().Trim(), lcEjer, loAsiento._Mensaje_Error);
                                llActuOk = false;
                            }

                            if (lcEjer != lcEjerDB) loEjer._Restablecer();

                        }

                        loAsiento = null;

                        if (llEfecRemP)
                            // Borrar asientos 400-401 que pudieran haber relacionados con el asiento de vencimiento/proveedor que se acaba de borrar.
                            //
                            this.borrarAsientosRelacionados(lcOldAsi);

                        // Esto ya no hace falta hacerlo, lo hace la clase PrevisionPago al hacer el _Save() unas lineas más arriba.
                        // CCR205142
                        // Comento el código
                        //if (loPrevision._Recc)
                        //{
                        //    // Si la previsión es de RECC llamamos a FOX para que haga el proceso respectivo de eliminación de asientos de RECC.

                        //    // Preparamos los parámetros para actualizar el RECC
                        //    // LPARAMETERS tcEmpresa, tcProveedor, tcFactura, tnNumereb, tnPendiente, tdEmision, tnDoccargo, tcPeriodo, tcAsi,  tcOldAsi, lnDigitosFra, tnOldImporte
                        //    object[] loParametros = new object[11]
                        //            {   tcEmpresa,
                        //                tcProveedor,
                        //                tcFactura,
                        //                tnOrden,
                        //                tnPendiente,
                        //                loPrevision._Fecha_Emision,
                        //                "", // DocCargo
                        //                tnPeriodo,
                        //                new string(' ',20),
                        //                lcOldAsi,
                        //                loPrevision._Importe
                        //             };
                        //    NETVFP._Ejecutar_Funcion_VFP("Modifica_Previs_Recc_Net", loParametros);
                        //}
                    }
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llActuOk = false;
            }

            return llActuOk;
        }


        #endregion MÉTODOS PRIVADOS PARA CONTABILIZACION DE REMESAS DE PREVISIONES DE PAGO


        #region MÉTODOS PRIVADOS PARA AÑADIR PREVISIONES DE PAGO A REMESA DE PAGO


        private bool addPrevisiones(DataRow[] taDataRowsPrevis, out DataRow[] taDataRowPrevisNoAnadidas)
        {
            bool llOk = true;

            this.remesaBancariaDetallePrevis._isLoading = true;

            // En este array de DataRows guardaremos las previsiones no añadidas que se devolverán al origen de la llamada.
            //
            taDataRowPrevisNoAnadidas = new DataRow[0];

            try
            {

                // Diccionario que vamos a utilizar para buscar previsiones en la remesa antes de añadirlas.
                //
                Dictionary<string, object> loDicBusqueda = new Dictionary<string, object>();
                loDicBusqueda["_Empresa"] = "";
                loDicBusqueda["_Periodo"] = 0;
                loDicBusqueda["_Cuenta"] = "";
                loDicBusqueda["_Factura"] = "";
                loDicBusqueda["_Orden"] = 0;
                loDicBusqueda["_Pendiente"] = 0;
                loDicBusqueda["_Emision"] = DateTime.Today;


                bool llCrearLinea = false;
                int lnContador = 0;
                foreach (DataRow aRowPrevision in taDataRowsPrevis)
                {
                    // Esto en teoria se filtra en origen pero por si acaso lo vuelvo a comprobar.
                    //
                    if (Convert.ToInt32(aRowPrevision["remesa"]) != 0 || Convert.ToBoolean(aRowPrevision["asiento"]) || 
                        !string.IsNullOrWhiteSpace(Convert.ToString(aRowPrevision["asi"])) || Convert.ToString(aRowPrevision["pagada"]) == "S" )
                    {
                        // Clono el DataRow  de la previsión que no añadiré a la remesa.
                        //
                        DataRow laRowPrevisNoAnadida = aRowPrevision.Table.NewRow();
                        laRowPrevisNoAnadida.ItemArray = aRowPrevision.ItemArray;

                        // Añado el DataRow al array de DataRows de previsiones no añadidas que retornaré.
                        //
                        Array.Resize(ref taDataRowPrevisNoAnadidas, taDataRowPrevisNoAnadidas.GetLength(0) + 1);
                        taDataRowPrevisNoAnadidas[taDataRowPrevisNoAnadidas.GetLength(0) - 1] = aRowPrevision;
                        continue;
                    }

                    // Busco si la factura ya está en la remesa.
                    //
                    loDicBusqueda["_Empresa"] = Convert.ToInt32(aRowPrevision["empresa"]);
                    loDicBusqueda["_Periodo"] = Convert.ToInt32(aRowPrevision["periodo"]);
                    loDicBusqueda["_Cuenta"] = Convert.ToString(aRowPrevision["proveedor"]);
                    loDicBusqueda["_Factura"] = Convert.ToString(aRowPrevision["factura"]);
                    loDicBusqueda["_Orden"] = Convert.ToInt32(aRowPrevision["numereb"]);
                    loDicBusqueda["_Pendiente"] = Convert.ToInt32(aRowPrevision["pendiente"]);
                    loDicBusqueda["_Emision"] = Convert.ToDateTime(aRowPrevision["emision"]);

                    RemesaBancariaDetallePrevis.Linea loLinea = this.remesaBancariaDetallePrevis._GetItem(loDicBusqueda);
                    if (loLinea != null)
                    {
                        // Ha encontrado ya la previsión de pago en la remesa, no la añado.

                        // Clono el DataRow  de la previsión que no añadiré a la remesa.
                        //
                        DataRow laRowPrevisNoAnadida = aRowPrevision.Table.NewRow();
                        laRowPrevisNoAnadida.ItemArray = aRowPrevision.ItemArray;

                        // Añado el DataRow al array de DataRows de previsiones no añadidas que retornaré.
                        //
                        Array.Resize(ref taDataRowPrevisNoAnadidas, taDataRowPrevisNoAnadidas.GetLength(0)+1);
                        taDataRowPrevisNoAnadidas[taDataRowPrevisNoAnadidas.GetLength(0)-1] = aRowPrevision;
                        continue;
                    }
                    else
                    {
                        if (lnContador == 0)
                        {
                            // Estamos añadiendo la primera previsión, hay que mirar si estamos situados en una linea en blanco o no, para aprovecharla
                            // si fuera el caso.
                            //
                            if (this.remesaBancariaDetallePrevis._CurrentItem == null)
                            {
                                llCrearLinea = true;
                            }
                            else
                            {
                                if (this.remesaBancariaDetallePrevis._CurrentItem.Fila_Plena())
                                    llCrearLinea = true;
                                else
                                    llCrearLinea = false;
                            }
                        }
                        else
                            llCrearLinea = true;


                        if (llCrearLinea)
                        {
                            // Creo nuevo registro de previsión en la remesa.
                            //
                            loLinea = this.remesaBancariaDetallePrevis._NewItem();
                        }
                        else
                            loLinea = this.remesaBancariaDetallePrevis._CurrentItem;

                        loLinea._Periodo = Convert.ToInt32(aRowPrevision["periodo"]);
                        
                        // El campo Emision siempre tendrá valor diferente de null.
                        //
                        loLinea._Emision = Convert.ToDateTime(aRowPrevision["emision"]);
                        loLinea._Factura = Convert.ToString(aRowPrevision["factura"]);
                        loLinea._Orden = Convert.ToInt32(aRowPrevision["numereb"]);
                        loLinea._Pendiente = Convert.ToInt32(aRowPrevision["pendiente"]);

                        loLinea._Cuenta = Convert.ToString(aRowPrevision["proveedor"]);
                        loLinea._Importe = Convert.ToDecimal(aRowPrevision["importe"]);

                        loLinea._ImporteDiv = Convert.ToDecimal(aRowPrevision["importediv"]);
                        loLinea._Cambio = Convert.ToDecimal(aRowPrevision["cambio"]);
                        //loLinea._Numbanco = Convert.ToInt32(aRowPrevision["num_banco"]);
                        loLinea._Divisa = Convert.ToString(aRowPrevision["divisa"]);

                        loLinea._ImporteDiv = Convert.ToDecimal(aRowPrevision["importediv"]);
                        loLinea._Cambio = Convert.ToDecimal(aRowPrevision["cambio"]);
                        //loLinea._Numbanco = Convert.ToInt32(aRowPrevision["num_banco"]);



                        // El campo Vencim siempre tendrá valor diferente de null.
                        //
                        loLinea._Vencim = Convert.ToDateTime(aRowPrevision["vencim"]);

                        //if (aRowPrevision["vencim2"] == DBNull.Value || aRowPrevision["vencim2"] == null)
                        //    loLinea._Vencim2 = null;
                        //else
                        //    loLinea._Vencim2 = Convert.ToDateTime(aRowPrevision["vencim2"]);

                        //loLinea._Concepto = Convert.ToString(aRowPrevision["concepto"]);

                        //loLinea._Asi = Convert.ToString(aRowPrevision["asi"]);
                        //loLinea._Asiento = Convert.ToBoolean(aRowPrevision["asiento"]);

                        // El campo FecReme podria tener valor null.
                        //
                        if (aRowPrevision["fecreme"] == DBNull.Value || aRowPrevision["fecreme"] == null)
                            loLinea._FecReme = null;
                        else
                            loLinea._FecReme = Convert.ToDateTime(aRowPrevision["fecreme"]);

                        //loLinea._Pagada = Convert.ToString(aRowPrevision["pagada"]);

                        // El campo Pago podria tener valor null.
                        //
                        //if (aRowPrevision["pago"] == DBNull.Value || aRowPrevision["pago"] == null)
                        //    loLinea._FecPago = null;
                        //else
                        //    loLinea._FecPago = Convert.ToDateTime(aRowPrevision["pago"]);

                        //loLinea._Banco = Convert.ToString(aRowPrevision["banco"]);

                        // Guardo inmediatamente los datos en la bd. para que en el registdro conste el nº de remesa y no se puede volver a añadir.
                        //
                        this.remesaBancariaDetallePrevis._SaveItem(loLinea);
                    }
                    lnContador++;
                }

                this._Totalizar();
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            this.remesaBancariaDetallePrevis._isLoading = false;

            return llOk;
        }


        private bool addPrevisiones(List<PrevisionPago> toLstPrevis, out List<PrevisionPago> tolstPrevisNoAnadidas)
        {
            bool llOk = true;

            this.remesaBancariaDetallePrevis._isLoading = true;

            // En esta lista guardaremos las previsiones no añadidas.
            //
            tolstPrevisNoAnadidas = new List<PrevisionPago>();

            try
            {

                // Diccionario que vamos a utilizar para buscar previsiones en la remesa antes
                // de añadirlas.
                //
                Dictionary<string, object> loDicBusqueda = new Dictionary<string, object>();
                loDicBusqueda["_Empresa"] = "";
                loDicBusqueda["_Periodo"] = 0;
                loDicBusqueda["_Cuenta"] = "";
                loDicBusqueda["_Factura"] = "";
                loDicBusqueda["_Orden"] = 0;
                loDicBusqueda["_Pendiente"] = 0;
                loDicBusqueda["_Emision"] = DateTime.Today;

                bool llCrearLinea = false;
                int lnContador = 0;
                foreach (PrevisionPago loPrevision in toLstPrevis)
                {
                    // Esto en teoria se filtra en origen pero por si acaso lo vuelvo a comprobar.
                    //
                    if (loPrevision._Remesa != 0 || loPrevision._Asiento || !string.IsNullOrWhiteSpace(loPrevision._Asi) || loPrevision._Pagada=="S" )
                    { 
                        tolstPrevisNoAnadidas.Add(loPrevision);
                        continue;
                    }

                    // Busco si la factura ya está en la remesa.
                    //
                    loDicBusqueda["_Empresa"] = loPrevision._Empresa;
                    loDicBusqueda["_Periodo"] = loPrevision._Ejercicio;
                    loDicBusqueda["_Cuenta"] = loPrevision._Proveedor;
                    loDicBusqueda["_Factura"] = loPrevision._Factura;
                    loDicBusqueda["_Orden"] = loPrevision._Numereb;
                    loDicBusqueda["_Pendiente"] = loPrevision._Pendiente;
                    loDicBusqueda["_Emision"] = loPrevision._Fecha_Emision;

                    RemesaBancariaDetallePrevis.Linea loLinea = this.remesaBancariaDetallePrevis._GetItem(loDicBusqueda);

                    if (loLinea != null)
                    {
                        tolstPrevisNoAnadidas.Add(loPrevision);
                        continue;
                    }
                    else
                    {
                        if (lnContador == 0)
                        {
                            // Estamos añadiendo la primera previsión, hay que mirar si estamos situados en una linea en blanco o no, para aprovecharla
                            // si fuera el caso.
                            //
                            if (this.remesaBancariaDetallePrevis._CurrentItem == null)
                            {
                                llCrearLinea = true;
                            }
                            else
                            {
                                if (this.remesaBancariaDetallePrevis._CurrentItem.Fila_Plena())
                                    llCrearLinea = true;
                                else
                                    llCrearLinea = false;
                            }
                        }
                        else
                            llCrearLinea = true;


                        if (llCrearLinea)
                        {
                            // Creo nuevo registro de previsión en la remesa.
                            //
                            loLinea = this.remesaBancariaDetallePrevis._NewItem();
                        }
                        else
                            loLinea = this.remesaBancariaDetallePrevis._CurrentItem;

                        loLinea._Periodo = loPrevision._Ejercicio;
                        loLinea._Emision = loPrevision._Fecha_Emision;
                        loLinea._Factura = loPrevision._Factura;
                        loLinea._Orden = loPrevision._Numereb;
                        loLinea._Pendiente = loPrevision._Pendiente;

                        loLinea._Cuenta = loPrevision._Proveedor;
                        loLinea._Vencim = loPrevision._Fecha_Vencim;
                        //loLinea._Vencim2 = loPrevision._Fecha_Vencim2;
                        loLinea._Concepto = loPrevision._Concepto;
                        loLinea._Importe = loPrevision._Importe;

                        loLinea._ImporteDiv = loPrevision._ImporteDiv;
                        loLinea._Cambio = loPrevision._Cambio;
                        loLinea._Divisa = loPrevision._Divisa;

                        loLinea._FecReme = loPrevision._Fecha_Remesa;

                        loLinea._NumBanco = loPrevision._Num_Banco;

                        // Guardo inmediatamente los datos en la bd. para que en el registdro conste el nº de remesa y no se puede volver a añadir.
                        this.remesaBancariaDetallePrevis._SaveItem(loLinea);
                    }
                    lnContador++;
                }

                this._Totalizar();
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            this.remesaBancariaDetallePrevis._isLoading = false;

            return llOk;
        }


        private bool crearCabeceraRemesa(ParamCreacionRemesaPago loParamCreaCnf)
        {

            bool llOk = true;
            string lcNumero = "";
            this._Error_Message = "";

            try
            {
                // Esto asigna nuevo número a la remesa.
                //
                lcNumero = this._Suma_Numero("");

                // Si tengo número lo asigno.
                //
                if (!string.IsNullOrWhiteSpace(lcNumero))
                {
                    this._Codigo = this._cEmpresa + "|" + lcNumero.Trim();
                    this._New();

                    this._Fecha = loParamCreaCnf._Fecha;
                    this._TipoDocumentoRemesa = TipoDocumentoRemesa.Previsiones;
                    this._EsquemaSepa = loParamCreaCnf._EsquemaSepa;
                    if (!string.IsNullOrWhiteSpace(loParamCreaCnf._Banco))
                        this._Banco = loParamCreaCnf._Banco;

                    this._Save();
                }
                else
                {
                    this._Error_Message = "No se pudo crear la remesa, no se pudo obtener un nuevo número de remesa.";
                    return false;
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
                this._Error_Message = e.Message;
                llOk = false;
            }

            return llOk;
        }

        
        #endregion MÉTODOS PRIVADOS PARA AÑADIR PREVISIONES DE PAGO A REMESA DE PAGO


        #endregion MÉTODOS PRIVADOS


        public class RemesaBancariaDetallePrevis : ewManteTRel<RemesaBancariaDetallePrevis.Linea, RemesaBancariaDetallePrevis.Clave>
        {
            #region PROPIEDADES PROTECTED


            protected string _lcMonedaEmpresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda"));


            protected ewMascara mascaraGranTotal;


            protected int _lnDigitos = Convert.ToInt32(EW_GLOBAL._GetLenCampo(KeyDiccionarioLenCampos.wn_digitos));


            protected int _nLenFactura = Convert.ToInt32(EW_GLOBAL._GetLenCampo(KeyDiccionarioLenCampos.wn_factcompra));


            #endregion PROPIEDADES PROTECTED


            #region PROPIEDADES PUBLICAS


            public RemesaBancariaPago _oRemesa
            {
                get
                {
                    return (RemesaBancariaPago)_ewMantePrincipal;
                }
            }


            public bool _isLoading = false;


            #endregion PROPIEDADES PUBLICAS


            #region CONSTRUCTORES


            public RemesaBancariaDetallePrevis()
            {
                this.crearEstructura();
            }


            #endregion CONSTRUCTORES


            #region MÉTODOS PRIVADOS


            private void crearEstructura()
            {
                Divisa loDivisa = new Divisa(this._lcMonedaEmpresa);

                string lcCuentaStdProv = Convert.ToString(EW_GLOBAL._GetVariable("wc_proveed"));
                string lcCuentaStdAcre = Convert.ToString(EW_GLOBAL._GetVariable("wc_acreed"));

                // Remuneraciones pendientes de pago (465)
                // Bug 171517, deben salir tambien en el browser de la columna proveedor las cuentas 465
                //
                string lcCuentaStrRemunPendPago = Convert.ToString(EW_GLOBAL._GetVariable("wc_remupenpag"));
                

                this.mascaraGranTotal = loDivisa._MascaraImporte;

                this._DataBase = "COMUNES";
                this._Tabla = "PREVIS";
                this._OrdenarPor = "VENCIM";

                this._Condicion = "";
                this._Titulo_Browser = "";


                ewCampoTRel def_Empresa = this._AddCampoTRel("_Empresa", "Empresa");
                def_Empresa._AnchoColumna = 7;
                def_Empresa._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Empresa._Editable = false;
                def_Empresa._Error_Duplicados = "";
                def_Empresa._Error_Validar_Dato = "";
                def_Empresa._ExpandirPunto = false;
                def_Empresa._FormatString = "";
                def_Empresa._PermiteDuplicados = true;
                def_Empresa._TipoColumna = gridColumnsTypes.Texto;
                def_Empresa._Titulo = "Empresa";
                def_Empresa._Updatable = true;
                def_Empresa._Validar_Asignar_Cargando = false;
                def_Empresa._Validar_Dato_BaseDatos = "";
                def_Empresa._Validar_Dato_Campos = "";
                def_Empresa._Validar_Dato_CampoTRel_Asignar = "";
                def_Empresa._Validar_Dato_Clave = "";
                def_Empresa._Validar_Dato_Tabla = "";
                def_Empresa._Visible = false;

                ewCampoTRel def_Numero = this._AddCampoTRel("_Numero", "Remesa");
                def_Numero._AnchoColumna = 7;
                def_Numero._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Numero._Editable = false;
                def_Numero._Error_Duplicados = "Ha introducido un valor que ya está asignado a otro registro. No se permiten valores duplicados en este campo.";
                def_Numero._Error_Validar_Dato = "Ha introducido un valor que no se ha encontrado en su mantenimiento origen.";
                def_Numero._ExpandirPunto = false;
                def_Numero._FormatString = "";
                def_Numero._PermiteDuplicados = true;
                def_Numero._TipoColumna = gridColumnsTypes.Número;
                def_Numero._Titulo = "Número";
                def_Numero._Updatable = true;
                def_Numero._Validar_Asignar_Cargando = false;
                def_Numero._Validar_Dato_BaseDatos = "";
                def_Numero._Validar_Dato_Campos = "";
                def_Numero._Validar_Dato_CampoTRel_Asignar = "";
                def_Numero._Validar_Dato_Clave = "";
                def_Numero._Validar_Dato_Tabla = "";
                def_Numero._Visible = false;

                ewCampoTRel def_Periodo = this._AddCampoTRel("_Periodo", "Periodo");
                def_Periodo._AnchoColumna = 7;
                def_Periodo._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Periodo._Editable = false;
                def_Periodo._Error_Duplicados = "Ha introducido un valor que ya está asignado a otro registro. No se permiten valores duplicados en este campo.";
                def_Periodo._Error_Validar_Dato = "Ha introducido un valor que no se ha encontrado en su mantenimiento origen.";
                def_Periodo._ExpandirPunto = false;
                def_Periodo._FormatString = "";
                def_Periodo._PermiteDuplicados = true;
                def_Periodo._TipoColumna = gridColumnsTypes.Número;
                def_Periodo._Titulo = "Periodo";
                def_Periodo._Updatable = true;
                def_Periodo._Validar_Asignar_Cargando = false;
                def_Periodo._Validar_Dato_BaseDatos = "";
                def_Periodo._Validar_Dato_Campos = "";
                def_Periodo._Validar_Dato_CampoTRel_Asignar = "";
                def_Periodo._Validar_Dato_Clave = "";
                def_Periodo._Validar_Dato_Tabla = "";
                def_Periodo._Visible = false;


                ewCampoTRel def_Emision = this._AddCampoTRel("_Emision", "Emision");
                def_Emision._AnchoColumna = 6;
                def_Emision._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Emision._Editable = false;
                def_Emision._Error_Duplicados = "";
                def_Emision._Error_Validar_Dato = "";
                def_Emision._ExpandirPunto = false;
                def_Emision._FormatString = "";
                def_Emision._PermiteDuplicados = true;
                def_Emision._TipoColumna = gridColumnsTypes.Fecha;
                def_Emision._Titulo = "Emision";
                def_Emision._Updatable = true;
                def_Emision._Validar_Asignar_Cargando = false;
                def_Emision._Validar_Dato_BaseDatos = "";
                def_Emision._Validar_Dato_Campos = "";
                def_Emision._Validar_Dato_CampoTRel_Asignar = "";
                def_Emision._Validar_Dato_Clave = "";
                def_Emision._Validar_Dato_Tabla = "";
                def_Emision._Visible = false;


                ewCampoTRel def_Factura = this._AddCampoTRel("_Factura", "Factura");
                if (this._nLenFactura <= 20)
                {
                    // Si el ancho del campo factura es 20 (defecto), fijamos la anchura de la
                    // columna al valor standar.
                    def_Factura._AnchoColumna = 12;
                    def_Factura._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                }
                else
                {
                    // CCR167227
                    // Si el ancho del campo factura es mayor a 20 quiere decir que lo han ampliaco
                    // y puede ser cualquier cosa, por tanto adaptamos su anchura al contenido del 
                    // valor de las celdas de la columna factura, para que siempre se vea el nº entero 
                    // y no quede nunca recortado.
                    //
                    def_Factura._AnchoColumna = (int)(this._nLenFactura/1.7);
                }

                def_Factura._Editable = true;
                def_Factura._Error_Duplicados = "";
                def_Factura._Error_Validar_Dato = "";
                def_Factura._ExpandirPunto = false;
                def_Factura._FormatString = "";
                def_Factura._PermiteDuplicados = true;
                def_Factura._TipoColumna = gridColumnsTypes.Texto;
                def_Factura._Titulo = "Factura";
                def_Factura._Updatable = true;
                def_Factura._Validar_Asignar_Cargando = false;
                def_Factura._Validar_Dato_BaseDatos = "";
                def_Factura._Validar_Dato_Campos = "";
                def_Factura._Validar_Dato_CampoTRel_Asignar = "";
                def_Factura._Validar_Dato_Clave = "";
                def_Factura._Validar_Dato_Tabla = "";
                def_Factura._Visible = true;
                def_Factura._Mante = new sage.ew.botones.btMante();
                def_Factura._Mante._NombreManteNet = "PREV_PAG";
                def_Factura._Mante._Tooltip = "Acceder al mantenimiento de la previsión de pago seleccionada.";


                // Configurar el browser que ha de enviar al formulario de seleccion de previsiones de pago. Rellenamos estas propiedades pero lo hacemos
                // solamente por compatibilida, realmente en f4_before_click se envia la ejecución al formulario especial de búsqueda de previsiones de 
                // pago frmPrevisionesPago.
                //
                def_Factura._Browser = new sage.ew.botones.btBrowser();
                def_Factura._Browser._Campos = "Factura, Proveedor";
                def_Factura._Browser._Campo_Predet = "Factura";
                def_Factura._Browser._Clave = "Factura";
                def_Factura._Browser._DataBase = "comunes";
                def_Factura._Browser._Tabla = "previs";
                def_Factura._Browser._Titulo = "Listado de previsiones de pago pendientes.";
                def_Factura._Browser._Titulos_Campos = "Factura, Proveedor";
                def_Factura._Browser.NombreMantenimiento = "PREV_PAG";
                def_Factura._Browser._Tooltip = "Buscar y añadir previsiones de pago a la remesa";

                ewCampoTRel def_Orden = this._AddCampoTRel("_Orden", "Numereb");
                def_Orden._AnchoColumna = 4;
                def_Orden._Mascara = new ewMascara("9999");
                def_Orden._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Orden._Editable = true;
                def_Orden._Error_Duplicados = "";
                def_Orden._Error_Validar_Dato = "";
                def_Orden._ExpandirPunto = false;
                def_Orden._FormatString = "";
                def_Orden._PermiteDuplicados = true;
                def_Orden._TipoColumna = gridColumnsTypes.Entero;
                def_Orden._Titulo = "Orden";
                def_Orden._Updatable = true;
                def_Orden._Validar_Asignar_Cargando = false;
                def_Orden._Validar_Dato_BaseDatos = "";
                def_Orden._Validar_Dato_Campos = "";
                def_Orden._Validar_Dato_CampoTRel_Asignar = "";
                def_Orden._Validar_Dato_Clave = "";
                def_Orden._Validar_Dato_Tabla = "";
                def_Orden._Visible = true;
                def_Orden._Mante = new sage.ew.botones.btMante();
                def_Orden._Mante._NombreManteNet = "PREV_PAG";
                def_Orden._Mante._Tooltip = "Acceder al mantenimiento de la previsión de pago seleccionada";

                // Configurar el browser que ha de enviar al formulario de seleccion de previsiones de pago. Rellenamos estas propiedades pero lo hacemos
                // solamente por compatibilida, realmente en f4_before_click se envia la ejecución al formulario especial de búsqueda de previsiones de 
                // pago frmPrevisionesPago.
                //
                def_Orden._Browser = new sage.ew.botones.btBrowser();
                def_Orden._Browser._Campos = "Factura, Proveedor";
                def_Orden._Browser._Campo_Predet = "Factura";
                def_Orden._Browser._Clave = "Factura";
                def_Orden._Browser._DataBase = "comunes";
                def_Orden._Browser._Tabla = "previs";
                def_Orden._Browser._Titulo = "Listado de previsiones de pago pendientes.";
                def_Orden._Browser._Titulos_Campos = "Factura, Proveedor";
                def_Orden._Browser.NombreMantenimiento = "PREV_PAG";
                def_Orden._Browser._Tooltip = "Buscar y añadir previsiones de pago a la remesa";


                ewCampoTRel def_Pendiente = this._AddCampoTRel("_Pendiente", "Pendiente");
                def_Pendiente._AnchoColumna = 4;
                def_Pendiente._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Pendiente._Editable = false;
                def_Pendiente._Error_Duplicados = "";
                def_Pendiente._Error_Validar_Dato = "";
                def_Pendiente._ExpandirPunto = false;
                def_Pendiente._FormatString = "";
                def_Pendiente._PermiteDuplicados = true;
                def_Pendiente._TipoColumna = gridColumnsTypes.Entero;
                def_Pendiente._Titulo = "Pendiente";
                def_Pendiente._Updatable = true;
                def_Pendiente._Validar_Asignar_Cargando = false;
                def_Pendiente._Validar_Dato_BaseDatos = "";
                def_Pendiente._Validar_Dato_Campos = "";
                def_Pendiente._Validar_Dato_CampoTRel_Asignar = "";
                def_Pendiente._Validar_Dato_Clave = "";
                def_Pendiente._Validar_Dato_Tabla = "";
                def_Pendiente._Visible = false;


                ewCampoTRel def_Cuenta = this._AddCampoTRel("_Cuenta", "Proveedor");
                def_Cuenta._AnchoColumna = 6;
                def_Cuenta._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Cuenta._Editable = true;
                def_Cuenta._Error_Duplicados = "";
                def_Cuenta._Error_Validar_Dato = "La cuenta introducida no existe.";
                def_Cuenta._ExpandirPunto = true;
                def_Cuenta._FormatString = "";
                def_Cuenta._PermiteDuplicados = true;
                def_Cuenta._TipoColumna = gridColumnsTypes.Texto;
                def_Cuenta._Titulo = "Proveedor";
                def_Cuenta._Updatable = true;
                def_Cuenta._Validar_Asignar_Cargando = true;
                def_Cuenta._Validar_Dato_BaseDatos = "GESTION";
                def_Cuenta._Validar_Dato_Campos = "NOMBRE";
                def_Cuenta._Validar_Dato_CampoTRel_Asignar = "_NombreCuenta";
                def_Cuenta._Validar_Dato_Clave = "CODIGO";
                def_Cuenta._Validar_Dato_Tabla = "cuentas";
                def_Cuenta._Visible = true;

                def_Cuenta._Browser = new sage.ew.botones.btBrowser();
                def_Cuenta._Browser._Campos = "Codigo,Nombre";
                def_Cuenta._Browser._Campo_Predet = "Nombre";
                def_Cuenta._Browser._Clave = "CODIGO";
                def_Cuenta._Browser._DataBase = "GESTION";
                def_Cuenta._Browser._Tabla = "cuentas";
                def_Cuenta._Browser._Titulo = "Buscar Cuenta";
                def_Cuenta._Browser._Titulos_Campos = "Código,Nombre";
                def_Cuenta._Browser._Condicion = "codigo in "+CONTABILIDAD._CuentasProveedores("codigo");


                def_Cuenta._Browser._Tooltip = "Acceder a la consulta de cuentas";
                def_Cuenta._Mante = new sage.ew.botones.btMante();
                def_Cuenta._Mante._NombreManteNet = "CUENTAS";
                def_Cuenta._Mante._Tooltip = "Acceder al mantenimiento de la cuenta de la previsión seleccionada";

                ewCampoTRel def_Nombrecuenta = this._AddCampoTRel("_Nombrecuenta", "");
                def_Nombrecuenta._AnchoColumna = 20;
                def_Nombrecuenta._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Nombrecuenta._Editable = false;
                def_Nombrecuenta._Error_Duplicados = "Ha introducido un valor que ya está asignado a otro registro. No se permiten valores duplicados en este campo.";
                def_Nombrecuenta._Error_Validar_Dato = "Ha introducido un valor que no se ha encontrado en su mantenimiento origen.";
                def_Nombrecuenta._ExpandirPunto = false;
                def_Nombrecuenta._FormatString = "";
                def_Nombrecuenta._PermiteDuplicados = true;
                def_Nombrecuenta._TipoColumna = gridColumnsTypes.Texto;
                def_Nombrecuenta._Titulo = "Nombre";
                def_Nombrecuenta._Updatable = false;
                def_Nombrecuenta._Validar_Asignar_Cargando = true;
                def_Nombrecuenta._Validar_Dato_BaseDatos = "GESTION";
                def_Nombrecuenta._Validar_Dato_Campos = "NOMBRE";
                def_Nombrecuenta._Validar_Dato_CampoTRel_Asignar = "_Nombrecuenta";
                def_Nombrecuenta._Validar_Dato_Clave = "CODIGO";
                def_Nombrecuenta._Validar_Dato_Tabla = "CUENTAS";
                def_Nombrecuenta._Visible = true;

                ewCampoTRel def_Vencim = this._AddCampoTRel("_Vencim", "Vencim");
                def_Vencim._AnchoColumna = 6;
                def_Vencim._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Vencim._Editable = false;
                def_Vencim._Error_Duplicados = "";
                def_Vencim._Error_Validar_Dato = "";
                def_Vencim._ExpandirPunto = false;
                def_Vencim._FormatString = "";
                def_Vencim._PermiteDuplicados = true;
                def_Vencim._TipoColumna = gridColumnsTypes.Fecha;
                def_Vencim._Titulo = "Vencimiento";
                def_Vencim._Updatable = true;
                def_Vencim._Validar_Asignar_Cargando = false;
                def_Vencim._Validar_Dato_BaseDatos = "";
                def_Vencim._Validar_Dato_Campos = "";
                def_Vencim._Validar_Dato_CampoTRel_Asignar = "";
                def_Vencim._Validar_Dato_Clave = "";
                def_Vencim._Validar_Dato_Tabla = "";
                def_Vencim._Visible = true;

                ewCampoTRel def_Importe = this._AddCampoTRel("_Importe", "Importe");
                def_Importe._AnchoColumna = 7;
                def_Importe._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Importe._Editable = false;
                def_Importe._Error_Duplicados = "";
                def_Importe._Error_Validar_Dato = "";
                def_Importe._ExpandirPunto = false;
                def_Importe._FormatString = "";
                def_Importe._PermiteDuplicados = true;
                def_Importe._TipoColumna = gridColumnsTypes.Número;
                def_Importe._Titulo = "Importe";
                def_Importe._Updatable = true;
                def_Importe._Validar_Asignar_Cargando = false;
                def_Importe._Validar_Dato_BaseDatos = "";
                def_Importe._Validar_Dato_Campos = "";
                def_Importe._Validar_Dato_CampoTRel_Asignar = "";
                def_Importe._Validar_Dato_Clave = "";
                def_Importe._Validar_Dato_Tabla = "";
                def_Importe._Visible = true;
                def_Importe._Mascara = mascaraGranTotal;

                ewCampoTRel def_ImporteDiv = this._AddCampoTRel("_ImporteDiv", "Importediv");
                def_ImporteDiv._AnchoColumna = 7;
                def_ImporteDiv._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_ImporteDiv._Editable = false;
                def_ImporteDiv._Error_Duplicados = "";
                def_ImporteDiv._Error_Validar_Dato = "";
                def_ImporteDiv._ExpandirPunto = false;
                def_ImporteDiv._FormatString = "";
                def_ImporteDiv._PermiteDuplicados = true;
                def_ImporteDiv._TipoColumna = gridColumnsTypes.Número;
                def_ImporteDiv._Titulo = "ImporteDiv";
                def_ImporteDiv._Updatable = true;
                def_ImporteDiv._Validar_Asignar_Cargando = false;
                def_ImporteDiv._Validar_Dato_BaseDatos = "";
                def_ImporteDiv._Validar_Dato_Campos = "";
                def_ImporteDiv._Validar_Dato_CampoTRel_Asignar = "";
                def_ImporteDiv._Validar_Dato_Clave = "";
                def_ImporteDiv._Validar_Dato_Tabla = "";
                def_ImporteDiv._Visible = false;
                def_ImporteDiv._Mascara = mascaraGranTotal;


                ewCampoTRel def_Cambio = this._AddCampoTRel("_Cambio", "Cambio");
                def_Cambio._AnchoColumna = 7;
                def_Cambio._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Cambio._Editable = false;
                def_Cambio._Error_Duplicados = "";
                def_Cambio._Error_Validar_Dato = "";
                def_Cambio._ExpandirPunto = false;
                def_Cambio._FormatString = "";
                def_Cambio._PermiteDuplicados = true;
                def_Cambio._TipoColumna = gridColumnsTypes.Número;
                def_Cambio._Titulo = "Cambio";
                def_Cambio._Updatable = true;
                def_Cambio._Validar_Asignar_Cargando = false;
                def_Cambio._Validar_Dato_BaseDatos = "";
                def_Cambio._Validar_Dato_Campos = "";
                def_Cambio._Validar_Dato_CampoTRel_Asignar = "";
                def_Cambio._Validar_Dato_Clave = "";
                def_Cambio._Validar_Dato_Tabla = "";
                def_Cambio._Visible = false;
                def_Cambio._Mascara = mascaraGranTotal;

                ewCampoTRel def_Divisa = this._AddCampoTRel("_Divisa", "Divisa");
                def_Divisa._AnchoColumna = 0;
                def_Divisa._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.Fill;
                def_Divisa._Editable = false;
                def_Divisa._Error_Duplicados = "";
                def_Divisa._Error_Validar_Dato = "";
                def_Divisa._ExpandirPunto = false;
                def_Divisa._FormatString = "";
                def_Divisa._PermiteDuplicados = true;
                def_Divisa._TipoColumna = gridColumnsTypes.Texto;
                def_Divisa._Titulo = "Divisa";
                def_Divisa._Updatable = true;
                def_Divisa._Validar_Asignar_Cargando = false;
                def_Divisa._Validar_Dato_BaseDatos = "";
                def_Divisa._Validar_Dato_Campos = "";
                def_Divisa._Validar_Dato_CampoTRel_Asignar = "";
                def_Divisa._Validar_Dato_Clave = "";
                def_Divisa._Validar_Dato_Tabla = "";
                def_Divisa._Visible = false;


                ewCampoTRel def_Concepto = this._AddCampoTRel("_Concepto", "Concepto");
                def_Concepto._AnchoColumna = 0;
                def_Concepto._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.Fill;
                def_Concepto._Editable = true;
                def_Concepto._Error_Duplicados = "";
                def_Concepto._Error_Validar_Dato = "";
                def_Concepto._ExpandirPunto = false;
                def_Concepto._FormatString = "";
                def_Concepto._PermiteDuplicados = true;
                def_Concepto._TipoColumna = gridColumnsTypes.Texto;
                def_Concepto._Titulo = "Concepto";
                def_Concepto._Updatable = true;
                def_Concepto._Validar_Asignar_Cargando = false;
                def_Concepto._Validar_Dato_BaseDatos = "";
                def_Concepto._Validar_Dato_Campos = "";
                def_Concepto._Validar_Dato_CampoTRel_Asignar = "";
                def_Concepto._Validar_Dato_Clave = "";
                def_Concepto._Validar_Dato_Tabla = "";
                def_Concepto._Visible = true;


                ewCampoTRel def_FecReme = this._AddCampoTRel("_FecReme", "Fecreme");
                def_FecReme._AnchoColumna = 6;
                def_FecReme._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_FecReme._Editable = false;
                def_FecReme._Error_Duplicados = "";
                def_FecReme._Error_Validar_Dato = "";
                def_FecReme._ExpandirPunto = false;
                def_FecReme._FormatString = "";
                def_FecReme._PermiteDuplicados = true;
                def_FecReme._TipoColumna = gridColumnsTypes.Fecha;
                def_FecReme._Titulo = "Fecha remesa";
                def_FecReme._Updatable = true;
                def_FecReme._Validar_Asignar_Cargando = false;
                def_FecReme._Validar_Dato_BaseDatos = "";
                def_FecReme._Validar_Dato_Campos = "";
                def_FecReme._Validar_Dato_CampoTRel_Asignar = "";
                def_FecReme._Validar_Dato_Clave = "";
                def_FecReme._Validar_Dato_Tabla = "";
                def_FecReme._Visible = false;

                ewCampoTRel def_NumBanco = this._AddCampoTRel("_NumBanco", "Num_Banco");
                def_NumBanco._AnchoColumna = 0;
                def_NumBanco._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.Fill;
                def_NumBanco._Editable = false;
                def_NumBanco._Error_Duplicados = "";
                def_NumBanco._Error_Validar_Dato = "";
                def_NumBanco._ExpandirPunto = false;
                def_NumBanco._FormatString = "";
                def_NumBanco._PermiteDuplicados = true;
                def_NumBanco._TipoColumna = gridColumnsTypes.Número;
                def_NumBanco._Titulo = "Num_Banco";
                def_NumBanco._Updatable = true;
                def_NumBanco._Validar_Asignar_Cargando = false;
                def_NumBanco._Validar_Dato_BaseDatos = "";
                def_NumBanco._Validar_Dato_Campos = "";
                def_NumBanco._Validar_Dato_CampoTRel_Asignar = "";
                def_NumBanco._Validar_Dato_Clave = "";
                def_NumBanco._Validar_Dato_Tabla = "";
                def_NumBanco._Visible = false;

                // Task 155061. Añadir forma de pago
                this._AddCampoTRel("_TipoPag", "TipoPag", false, true, false);

                return;
            }


            #endregion MÉTODOS PRIVADOS


            #region MÉTODOS PUBLIC OVERRIDE SOBREESCRITOS DE EWMANTTREL


            public override void _Load()
            {
                RemesaBancariaPago document = (RemesaBancariaPago)this._ewMantePrincipal;

                this._Claves._Empresa._Valor = document._Empresa;
                this._Claves._Numero._Valor = Convert.ToInt32(document._Numero);

                this._isLoading = true;

                base._Load();

                this._isLoading = false;
            }


            public override bool _DeleteItem(RemesaBancariaDetallePrevis.Linea toItem)
            {
                bool deleted = false;

                deleted = base._DeleteItem(toItem);

                if (deleted)
                {
                    if (toItem.Fila_Plena())
                    {
                        // Actualizo la bd. para que puedan añadir el pagaré de nuevo, si lo desean.
                        //
                        string sql = "Update " + DB.SQLDatabase("comunes", "previs") + " " +
                                 "set remesa=0, fecreme=null " +
                                 "Where empresa=" + DB.SQLString(toItem._Empresa) + " and " +
                                 "proveedor=" + DB.SQLString(toItem._Cuenta) + " and " +
                                 "factura=" + DB.SQLString(toItem._Factura) + " and " +
                                 "numereb=" + DB.SQLString(toItem._Orden) + " and " +
                                 "pendiente=" + DB.SQLString(toItem._Pendiente) + " and " +
                                 "periodo=" + DB.SQLString(toItem._Periodo);
                        DB.SQLExec(sql);
                    }

                    // Refrescar los totales de la remesa.
                    //
                    this._oRemesa._Totalizar();
                }

                return deleted;
            }


            public override Boolean _SaveItem(RemesaBancariaDetallePrevis.Linea toItem)
            {
                bool lbRetorn = true;
                string sql = "";

                sql = "Update " + DB.SQLDatabase("comunes", "previs") + " " +
                      "set remesa=" +DB.SQLString(toItem._Numero)+", concepto="+DB.SQLString(toItem._Concepto)+" "+
                      "Where empresa=" + DB.SQLString(toItem._Empresa) + " and " +
                      "proveedor=" + DB.SQLString(toItem._Cuenta) + " and " +
                      "factura=" + DB.SQLString(toItem._Factura) + " and " +
                      "numereb=" + DB.SQLString(toItem._Orden) + " and " +
                      "pendiente=" + DB.SQLString(toItem._Pendiente) + " and " +
                      "periodo=" + DB.SQLString(toItem._Periodo);
                lbRetorn = DB.SQLExec(sql);

                return lbRetorn;
            }


            #endregion MÉTODOS PUBLIC OVERRIDE SOBREESCRITOS DE EWMANTTREL


            #region MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE EWMANTETREL


            protected override bool _BorrarRegistro(DataRow dataroweliminar)
            {
                bool lbRetorn = true;
                string sql = "";

                sql = "Update " + DB.SQLDatabase("comunes", "previs") +" "+
                      "set remesa=0 "+
                      "Where empresa=" + DB.SQLString(Convert.ToString(dataroweliminar["empresa"])) + " and " +
                      "proveedor=" + DB.SQLString(Convert.ToString(dataroweliminar["proveedor"])) + " and " +
                      "factura=" + DB.SQLString(Convert.ToString(dataroweliminar["factura"])) + " and " +
                      "numereb=" + DB.SQLString(Convert.ToInt32(dataroweliminar["numereb"])) + " and " +
                      "pendiente=" + DB.SQLString(Convert.ToInt32(dataroweliminar["pendiente"])) + " and " +
                      "periodo=" + DB.SQLString(Convert.ToInt32(dataroweliminar["periodo"])); ;
                lbRetorn = DB.SQLExec(sql);

                return lbRetorn;
            }


            protected override bool _BorrarRegistro(RemesaBancariaDetallePrevis.Linea loItem)
            {
                bool lbRetorn = true;
                string sql = "";

                sql = "Update " + DB.SQLDatabase("comunes", "previs") + " " +
                      "set remesa=0 " +
                      "Where empresa=" + DB.SQLString(loItem._Empresa) + " and " +
                      "proveedor=" + DB.SQLString(loItem._Cuenta) + " and " +
                      "factura=" + DB.SQLString(loItem._Factura) + " and " +
                      "numereb=" + DB.SQLString(loItem._Orden) + " and " +
                      "pendiente=" + DB.SQLString(loItem._Pendiente) + " and " +
                      "periodo=" + DB.SQLString(loItem._Periodo);
                lbRetorn = DB.SQLExec(sql);

                return lbRetorn;
            }


            protected override bool _BorrarTodosRegistros()
            {
                bool llOk = true;
                string lcSql = "";

                try
                {
                    lcSql = "UPDATE " + DB.SQLDatabase("COMUNES", "PREVIS") + " " +
                            "SET REMESA=0 " +
                            "WHERE EMPRESA=" + DB.SQLString(this._Claves._Empresa._Valor) + " AND " +
                            "REMESA=" + Convert.ToString(this._Claves._Numero._Valor).Trim();
                    llOk = DB.SQLExec(lcSql);
                }
                catch (Exception e)
                {
                    DB.Registrar_Error(e);
                    this._oRemesa._Error_Message = e.Message;
                    llOk = false;
                }

                return llOk;
            }


            #endregion MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE EWMANTETREL


            public class Clave : IClaves
            {
                public ClaveTRel _Empresa { get; set; }


                public ClaveTRel _Numero { get; set; }


                public ClaveTRel _Periodo { get; set; }


                public ClaveTRel _Cuenta { get; set; }


                public ClaveTRel _Factura { get; set; }


                public ClaveTRel _Orden { get; set; }


                public ClaveTRel _Pendiente { get; set; }


                public ClaveTRel _Emision { get; set; }


                public Clave()
                {
                    // Definición de las propiedades de cada una de les claves

                    // Empresa de la remesa.
                    //
                    this._Empresa = new ClaveTRel();
                    this._Empresa._EsFiltro = true;
                    this._Empresa._EsCampoLinea = false;


                    // Número de la remesa.
                    //
                    this._Numero = new ClaveTRel();
                    this._Numero._EsFiltro = true;
                    this._Numero._EsCampoLinea = false;

                    
                    // Campo Periodo de la previsión incorporada a la remesa.
                    //
                    this._Periodo = new ClaveTRel();
                    this._Periodo._EsFiltro = false;
                    this._Periodo._EsCampoLinea = false;


                    // Campo Proveedor de la previsión incorporada a la remesa.
                    //
                    this._Cuenta = new ClaveTRel();
                    this._Cuenta._EsFiltro = false;
                    this._Cuenta._EsCampoLinea = false;


                    // Campo Factura de la previsión incorporada a la remesa.
                    //
                    this._Factura = new ClaveTRel();
                    this._Factura._EsFiltro = false;
                    this._Factura._EsCampoLinea = false;


                    // Campo Orden de la previsión incorporada a la remesa.
                    //
                    this._Orden = new ClaveTRel();
                    this._Orden._EsFiltro = false;
                    this._Orden._EsCampoLinea = false;


                    // Campo Pendiente de la previsión incorporada a la remesa.
                    //
                    this._Pendiente = new ClaveTRel();
                    this._Pendiente._EsFiltro = false;
                    this._Pendiente._EsCampoLinea = false;


                    // Campo Fecha Emision de la previsión incorporada a la remesa.
                    //
                    this._Emision = new ClaveTRel();
                    this._Emision._EsFiltro = false;
                    this._Emision._EsCampoLinea = false;

                    return;
                }
            }


            public class Linea : ILinTRel, IRemesaBancariaLineaPrevision
            {
                [ReportProperty("Empresa", "", "Empresa:")]
                public string _Empresa
                {
                    get
                    {
                        return this._cEmpresa;
                    }
                    set
                    {
                        this._cEmpresa = value;
                    }
                }
                private string _cEmpresa = "";


                [ReportProperty("Numero", "", "Nº Remesa:")]
                public int _Numero
                {
                    get
                    {
                        return this._cNumero;
                    }
                    set
                    {
                        this._cNumero = value;
                    }
                }
                private int _cNumero = 0;


                [ReportProperty("Periodo", "", "Periodo:")]
                public int _Periodo
                {
                    get
                    {
                        return this._nPeriodo;
                    }
                    set
                    {
                        this._nPeriodo = value;
                    }
                }
                private int _nPeriodo = 0;


                [ReportProperty("FecEmision", "dd/MM/yyyy", "Fecha emisión:")]
                public DateTime? _Emision
                {
                    get
                    {
                        return this._dEmision;
                    }
                    set
                    {
                        this._dEmision = value;
                    }
                }
                private DateTime?_dEmision = DateTime.Today;


                [ReportProperty("Factura", "", "Factura:")]
                public string _Factura
                {
                    get
                    {
                        return this._cFactura;
                    }
                    set
                    {
                        int lnLenFacturaCompra = Convert.ToInt32(EW_GLOBAL._GetLenCampo(KeyDiccionarioLenCampos.wn_factcompra));
                        string lcValorAnterior = this._cFactura;

                        if (value == null)
                            value = new string(' ', lnLenFacturaCompra);

                        value = value.Trim().PadLeft(lnLenFacturaCompra,' ');

                        if (value.Trim() != lcValorAnterior.Trim())
                        {
                            if (this._oParent._isLoading)
                            {
                                this._cFactura = value;
                            }
                            else
                            {
                                if (!string.IsNullOrWhiteSpace(value) && this._nOrden != 0 && !string.IsNullOrWhiteSpace(this._cCuenta))
                                {
                                    // Si tenemos factura, orden y códig proveedor hemos de validar que exista la previsión, que esté pendiente, y que no esté añadida ya a la remesa
                                    //
                                    PrevisionPago loPrevisionPago;
                                    bool llOk = this.validarPrevisionPago(value, this._nOrden, this._cCuenta, out loPrevisionPago);
                                    if (llOk)
                                    {
                                        this._cFactura = value;
                                        this.rellenarLineaDatosPrevisionPago(loPrevisionPago);
                                    }
                                }
                                else
                                    this._cFactura = value;
                            }
                        }
                    }
                }
                private string _cFactura = "";
                
                [ReportProperty("Orden", "", "Orden:")]
                public Int32 _Orden
                {
                    get
                    {
                        return this._nOrden;
                    }
                    set
                    {
                        int lnValorAnterior = this._nOrden;

                        if (value != lnValorAnterior)
                        {
                            if (this._oParent._isLoading)
                            {
                                this._nOrden = value;
                            }
                            else
                            {
                                if (!string.IsNullOrWhiteSpace(this._cFactura) && value != 0 && !string.IsNullOrWhiteSpace(this._cCuenta))
                                {
                                    // Si tenemos factura, orden y código de proveedor hemos de validar que exista la previsión, que esté pendiente, y que no esté añadida ya a la remesa
                                    //
                                    PrevisionPago loPrevisionPago;
                                    bool llOk = this.validarPrevisionPago(this._cFactura, value, this._cCuenta, out loPrevisionPago);
                                    if (llOk)
                                    {
                                        this._nOrden = value;
                                        this.rellenarLineaDatosPrevisionPago(loPrevisionPago);
                                    }
                                }
                                else
                                    this._nOrden = value;
                            }
                        }
                    }
                }
                private Int32 _nOrden = 0;


                [ReportProperty("Pendiente", "", "Pendiente:")]
                public Int32 _Pendiente
                {
                    get
                    {
                        return this._nPendiente;
                    }
                    set
                    {
                        this._nPendiente = value;
                    }
                }
                private Int32 _nPendiente = 0;


                [ReportProperty("Cuenta", "", "Cuenta:")]
                public string _Cuenta
                {
                    get
                    {
                        return this._cCuenta;
                    }
                    set
                    {
                        string lcValorAnterior = this._cCuenta;

                        if (value == null)
                            value = "";

                        value = FUNCTIONS._Punto_Por_Ceros(value);

                        if (value.Trim() != lcValorAnterior.Trim())
                        {
                            if (this._oParent != null)
                            {
                                if (this._oParent.CamposTRel_Validar_Valor("_Cuenta", value, this))
                                    value = this._cCuenta;
                            }

                            if (this._oParent._isLoading)
                            {
                                this._cCuenta = value;
                            }
                            else
                            {
                                if (!string.IsNullOrWhiteSpace(this._cFactura) && this._nOrden != 0 && !string.IsNullOrWhiteSpace(value) )
                                {
                                    // Si tenemos factura, orden y código de proveedor hemos de validar que exista la previsión, que esté pendiente, y que no esté añadida ya a la remesa
                                    //
                                    PrevisionPago loPrevisionPago;
                                    bool llOk = this.validarPrevisionPago(this._cFactura, this._nOrden, value, out loPrevisionPago);
                                    if (llOk)
                                    {
                                        this._cCuenta = value;
                                        this.rellenarLineaDatosPrevisionPago(loPrevisionPago);
                                    }
                                    else
                                    {
                                        // Quito el nombre de la cuenta que habrá puesto al validar el código de cuenta.
                                        //
                                        this._NombreCuenta = "";
                                    }
                                }
                                else
                                    this._cCuenta = value;
                            }

                        }
                    }
                }
                private string _cCuenta = "";


                [ReportProperty("Nombrecuenta", "", "Nombre:")]
                public string _NombreCuenta
                {
                    get
                    {
                        return this._cNombrecuenta;
                    }
                    set
                    {
                        this._cNombrecuenta = value;
                    }
                }
                private string _cNombrecuenta = "";


                [ReportProperty("Vencim", "dd/MM/yyyy", "Vencimiento:")]
                public DateTime? _Vencim
                {
                    get
                    {
                        return this._dVencim;
                    }
                    set
                    {
                        this._dVencim = value;
                    }
                }
                private DateTime? _dVencim = DateTime.Today;


                [ReportProperty("Importe", "", "Importe:")]
                public decimal _Importe
                {
                    get
                    {
                        return this._nImporte;
                    }
                    set
                    {
                        this._nImporte = value;
                    }
                }
                private decimal _nImporte = 0;



                [ReportProperty("ImporteDiv", "", "Importe (Div):")]
                public decimal _ImporteDiv
                {
                    get
                    {
                        return this._nImporteDiv;
                    }
                    set
                    {
                        this._nImporteDiv = value;
                    }
                }
                private decimal _nImporteDiv = 0;


                [ReportProperty("Cambio", "", "Cambio:")]
                public decimal _Cambio
                {
                    get
                    {
                        return this._nCambio;
                    }
                    set
                    {
                        this._nCambio = value;
                    }
                }
                private decimal _nCambio = 0;


                [ReportProperty("Divisa", "", "Divisa:")]
                public string _Divisa
                {
                    get
                    {
                        return this._cDivisa;
                    }
                    set
                    {
                        this._cDivisa = value;
                    }
                }
                private string _cDivisa = "";


                [ReportProperty("Concepto", "", "Concepto:")]
                public string _Concepto
                {
                    get
                    {
                        return this._cConcepto;
                    }
                    set
                    {
                        this._cConcepto = value;
                    }
                }
                private string _cConcepto = "";

                // Task 155061
                [ReportProperty("TipoPag", "", "TipoPag:")]
                public string _TipoPag
                {
                    get
                    {
                        return this._cTipoPag;
                    }
                    set
                    {
                        this._cTipoPag = value;
                    }
                }
                private string _cTipoPag = "";

                // Task 155061
                [ReportProperty("NumeReb", "", "NumeReb:")]
                public int _NumeReb
                {
                    get
                    {
                        return this._nNumeReb;
                    }
                    set
                    {
                        this._nNumeReb = value;
                    }
                }
                private int _nNumeReb = 0;

                private Int32 _nNumBanco = 99;
                public Int32 _NumBanco
                {
                    get
                    {
                        return this._nNumBanco;
                    }
                    set
                    {
                        this._nNumBanco = value;
                    }
                }

                [ReportProperty("BANCO", "", "Cuenta bancaria:")]
                public String _CuentaBancaria
                {
                    get
                    {
                        String lcSql;
                        String lcCuenta = "";
                        DataTable loDt = new DataTable();
                        Boolean lbOcultar;

                        if (_NumBanco != 99)
                        {
                            lcSql = String.Format("SELECT * FROM {0} WHERE CODIGO = {1} AND PROVEEDOR = {2}", DB.SQLDatabase("GESTION", "BANC_PRO"), _NumBanco, DB.SQLString(_Cuenta));
                            DB.SQLExec(lcSql, ref loDt);

                            if (loDt.Rows.Count == 0)
                            {
                                lcSql = String.Format("SELECT * FROM {0} WHERE CODIGO = {1} AND CUENTA = {2}", DB.SQLDatabase("GESTION", "BANC_CUE"), _NumBanco, DB.SQLString(_Cuenta));
                                DB.SQLExec(lcSql, ref loDt);
                            }

                            // Si tenemos una cuenta de anticipos 460 vamos a consultar la información del IBAN en la cuenta del trabajador que esté relacionado
                            // La función CONTABILIDAD._DigitosNivel3CuentaAnticipoTrabajador devuelve en blanco si está marcado como ficha proveedor la cuenta de Anticipo de trabajador 460. En tal caso se trata como proveedor.
                            // Realizamos un LEFT JOIN, se puede dar el caso de tener 2 cuentas 465 con la misma 460 y que no tengamos registro en la tabla BANC_CUE
                            if (loDt.Rows.Count == 0 && !string.IsNullOrWhiteSpace(_Cuenta) && CONTABILIDAD._EsAnticipoTrabajador(_Cuenta) && !string.IsNullOrWhiteSpace(CONTABILIDAD._DigitosNivel3CuentaAnticipoTrabajador()))
                            {
                                DataTable ldtBancoAnticipoTrabajador = new DataTable();

                                bool llOk = DB.SQLExec("SELECT b.banco, b.ctabanco, b.ctasucur, b.digcon, b.ctacuenta, b.iban, b.cuentaiban, b.orden, b.swift ,b.tipocta  " +
                                                       $"FROM {DB.SQLDatabase("GESTION", "CUENTAS")} c LEFT JOIN {DB.SQLDatabase("GESTION", "BANC_CUE")} b ON c.codigo = b.cuenta " +
                                                       $"WHERE c.anticiprem = {DB.SQLString(_Cuenta)}", ref ldtBancoAnticipoTrabajador);

                                if (llOk && ldtBancoAnticipoTrabajador != null && ldtBancoAnticipoTrabajador.Rows.Count ==  1)
                                    loDt = ldtBancoAnticipoTrabajador.Copy();

                                FUNCTIONS._DisposeDatatable(ref ldtBancoAnticipoTrabajador);
                            }

                            if (loDt.Rows.Count > 0)
                            {
                                lbOcultar = !usuario.Usuario._This._Opcesp("0084");
                                lcCuenta = functions.FUNCTIONS._Formatear_Cuenta_Bancaria(Convert.ToString(loDt.Rows[0]["tipocta"]), Convert.ToString(loDt.Rows[0]["iban"]), Convert.ToString(loDt.Rows[0]["cuentaiban"]).Trim(), lbOcultar);
                            }
                        }
                        return lcCuenta;
                    }
                }

                [ReportProperty("Fecreme", "dd/MM/yyyy", "Fecha remesa:")]
                public DateTime? _FecReme
                {
                    get
                    {
                        return this._dFecReme;
                    }
                    set
                    {
                        this._dFecReme = value;
                    }
                }
                private DateTime? _dFecReme = DateTime.Today;


                public dynamic _Parent
                {
                    get { return this._oParent; }
                    set { this._oParent = (RemesaBancariaDetallePrevis)value; }
                }
                protected RemesaBancariaDetallePrevis _oParent;


                public RemesaBancariaPago _oRemesa
                {
                    get { return this._oParent._oRemesa; }
                }


                public Linea()
                {

                }


                public bool Fila_Plena()
                {
                    bool lbFilaPlena = true;

                    lbFilaPlena = !string.IsNullOrWhiteSpace(this._Factura) && this._Orden != 0 &&
                                  !string.IsNullOrWhiteSpace(this._Cuenta);

                    return lbFilaPlena;
                }


                private bool validarPrevisionPago(string tcFactura, int tnOrden, string tcProveedor, out PrevisionPago toPrevisionPago)
                {
                    string lcEmpresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
                    toPrevisionPago = new PrevisionPago();


                    // Busco todas las previsiones con idéntico nº de factura, orden y proveedor, podría darse el caso de que hubiera
                    // más de una p.e. al pertenecer a diferentes ejercicios, en ese caso el usuario deberá seleccionar cual
                    // quiere incorporar a la remesa.
                    //
                    DataTable ldtPrevisionesFacturaOrden = CONTABILIDAD._PrevisionesPagoFacturaOrden(lcEmpresa, tcProveedor, tcFactura, tnOrden, false);
                    if (ldtPrevisionesFacturaOrden.Rows.Count == 0)
                    {
                        // No existe ninguna previsión de pago con este número de factura, orden y proveedor, ni pendiente ni pagada,
                        // ni en el ejercicio activo ni en cualquier otro ejercicio.
                        //
                        // Informar de que la previsión NO EXISTE.
                        //
                        this._oRemesa._Error_Message_LineaRemesa = "La previsión de pago introducida no existe.";
                        return false;
                    }


                    // Me quedo con las previsiones pendientes de pago.
                    //
                    DataView ldviewPrevPendi = ldtPrevisionesFacturaOrden.DefaultView;
                    ldviewPrevPendi.RowFilter = "remesa=0 and asi='' and pagada<>'S'";
                    DataTable ldtPrevisionesPendientes = ldviewPrevPendi.ToTable();
                    if (ldtPrevisionesPendientes.Rows.Count == 0 && ldtPrevisionesFacturaOrden.Rows.Count > 0)
                    {
                        // La previsión introducida ya está pagada. Puede que hubiera más de una previsión con este número
                        // de factura, orden y proveedor, en diferentes ejercicios, pero todas están pagadas.
                        //
                        // Informar de que la previsión ya está pagada.
                        //
                        this._oRemesa._Error_Message_LineaRemesa = "La previsión de pago introducida ya está remesada o pagada.";
                        return false;
                    }

                    int lnPeriodo = 0, lnPendiente = 0;
                    if (ldtPrevisionesPendientes.Rows.Count > 1)
                    {
                        if (this._oRemesa._LinkForm || this._oRemesa._lLinkadoFormulario)
                        {
                            // Se ha detectado más de una previsión con este nº de factura y orden, probablemente de diferentes
                            // ejercicios, se solicitará al usuario que escoja una.
                            //
                            ldtPrevisionesPendientes.Columns["empresa"].ExtendedProperties.Add("NoVisible", true);
                            ldtPrevisionesPendientes.Columns["pendiente"].ExtendedProperties.Add("NoVisible", true);
                            ldtPrevisionesPendientes.Columns["importediv"].ExtendedProperties.Add("NoVisible", true);
                            ldtPrevisionesPendientes.Columns["remesa"].ExtendedProperties.Add("NoVisible", true);
                            ldtPrevisionesPendientes.Columns["asi"].ExtendedProperties.Add("NoVisible", true);
                            ldtPrevisionesPendientes.Columns["pagada"].ExtendedProperties.Add("NoVisible", true);

                            ldtPrevisionesPendientes.Columns["numereb"].Caption = "Orden";
                            ldtPrevisionesPendientes.Columns["emision"].Caption = "Emisión";
                            ldtPrevisionesPendientes.Columns["vencim"].Caption = "Vencimiento";

                            formul.Forms.Seleccionar loFormSeleccionar = new formul.Forms.Seleccionar();
                            loFormSeleccionar._Boto_Aceptar = true;
                            loFormSeleccionar.MinimumSize = new System.Drawing.Size(400, 250);
                            
                            // Pongo la altura máxima para que si la lista es muy extensa no se salga de la pantalla y los dos botones no queden ocultos.
                            //
                            loFormSeleccionar.MaximumSize = new System.Drawing.Size(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height - 100);

                            loFormSeleccionar._Ajustar_Alto_A_Registros = true;
                            loFormSeleccionar._HeightMin = 250;
                            loFormSeleccionar._Texto_Cancelar = "&Salir";
                            loFormSeleccionar._ReadOnly = true;
                            loFormSeleccionar._Solo_lectura = true;
                            loFormSeleccionar._Redimensionable = false;
                            loFormSeleccionar._MultipleSeleccion = true;
                            loFormSeleccionar._Titulo = "Previsiones de pago pendientes con idéntico nº de factura y orden";
                            loFormSeleccionar._Texto_Aceptar = "S&eleccionar";
                            loFormSeleccionar._DataTable = ldtPrevisionesPendientes;

                            bool llSeleccionada = false, llSalir = false;
                            do
                            {
                                loFormSeleccionar._ShowDialog();
                                if (DialogResult.OK == loFormSeleccionar.DialogResult && loFormSeleccionar._DataRowSelect != null)
                                {
                                    lnPeriodo = Convert.ToInt32(loFormSeleccionar._DataRowSelect["periodo"]);
                                    lnPendiente = Convert.ToInt32(loFormSeleccionar._DataRowSelect["pendiente"]);
                                    llSeleccionada = true;
                                }
                                else
                                {
                                    llSalir = true;
                                }
                            }
                            while (!llSeleccionada && !llSalir);

                            if (!llSeleccionada)
                            {
                                // No se ha seleccionado ninguna prevision, salimos.
                                return false;
                            }
                        }
                        else
                        {
                            // Si no trabajo contra formulario y tenemos más de una previsión el mismo número de factura
                            // y orden, selecciono de forma automática la primera.
                            //
                            lnPeriodo = Convert.ToInt32(ldtPrevisionesPendientes.Rows[0]["periodo"]);
                            lnPendiente = Convert.ToInt32(ldtPrevisionesPendientes.Rows[0]["pendiente"]);
                        }
                    }
                    else
                    {
                        // Se detectó una única previsión de pago pendiente.
                        //
                        lnPeriodo = Convert.ToInt32(ldtPrevisionesPendientes.Rows[0]["periodo"]);
                        lnPendiente = Convert.ToInt32(ldtPrevisionesPendientes.Rows[0]["pendiente"]);
                    }


                    // Caso de que la remesa sea de proveedores SEPA verificaremos que el proveedor de la previsión de pago tenga marcado en ficha
                    // "Gestión de SEPA".
                    //
                    if (this._oRemesa._EsquemaSepa != TipoEsquemaRemesaSepaPagos.Ninguno)
                    {
                        Proveedor loProv = new Proveedor();
                        loProv._Codigo = tcProveedor;
                        if (loProv._Estado == _EstadosMantenimiento.MostrandoRegistro)
                        {
                            if (!loProv._CSB_Sepa)
                            {
                                // La previsión seleccionada no tiene mandato SEPA y la remesa es SEPA, no se puede agregar.
                                //
                                this._oRemesa._Error_Message_LineaRemesa = "La previsión de pago introducida corresponde a un proveedor ('"+ tcProveedor + "') que no tiene marcado en su ficha 'Gestión de SEPA', en cambio, "+
                                                                           "la remesa es de tipo SEPA. No se puede agregar la previsión de pago a la remesa.";
                                return false;
                            }
                        }
                    }

                    // Verificar que la previsión de pago no esté agregada ya a la remesa.
                    //
                    Dictionary<string, object> loDicBusqueda = new Dictionary<string, object>();
                    loDicBusqueda["_Empresa"] = lcEmpresa;
                    loDicBusqueda["_Periodo"] = lnPeriodo;
                    loDicBusqueda["_Cuenta"] = tcProveedor;
                    loDicBusqueda["_Factura"] = tcFactura;
                    loDicBusqueda["_Orden"] = tnOrden;
                    loDicBusqueda["_Pendiente"] = lnPendiente;

                    RemesaBancariaDetallePrevis.Linea loLinea = this._oParent._GetItem(loDicBusqueda);
                    if (loLinea != null)
                    {
                        this._oRemesa._Error_Message_LineaRemesa = "La previsión de pago introducida ya está incorporada a la remesa.";
                        // La previsión ya está agregada a la remesa.
                        return false;
                    }
                    else
                    {
                        // Se puede agregar la previsión a la remesa, preparo el objeto PrevisionPago que devolverá al origen
                        // de la llamada.
                        //
                        toPrevisionPago._Empresa = lcEmpresa;
                        toPrevisionPago._Ejercicio = lnPeriodo;
                        toPrevisionPago._Proveedor = tcProveedor;
                        toPrevisionPago._Factura = tcFactura;
                        toPrevisionPago._Numereb = tnOrden;
                        toPrevisionPago._Pendiente = lnPendiente;     
                        toPrevisionPago._Load();


                        // Task 180446 - En un tipo de esquema diferente de ninguno, no dejar entrar previsiones en negativo.
                        if (this._oRemesa._EsquemaSepa != TipoEsquemaRemesaSepaPagos.Ninguno && toPrevisionPago._Importe < 0)
                        {
                            this._oRemesa._Error_Message_LineaRemesa = "No es posible incluir previsiones con signo negativo en los ficheros SEPA, " +
                                                                        "utilice el tipo de esquema 'Ninguno' para gestionar remesas sin fichero para gestión interna.";
                            return false;
                        }

                        // Hasta ahora se permitía entrada de previsiones en divisa diferente de la moneda de la empresa y se mostraban
                        // en un color diferente. A partir de esta tarea 197214 ya no se permite su entrada.
                        //
                        if (!string.IsNullOrWhiteSpace(toPrevisionPago._Divisa) && toPrevisionPago._Divisa != EW_GLOBAL._Empresa._Moneda)
                        {
                            Divisa loDivisaEmpresa = new Divisa(EW_GLOBAL._Empresa._Moneda);
                            string lcNombreMonedaEmpresa = loDivisaEmpresa._Nombre.Trim();
                            lcNombreMonedaEmpresa = !string.IsNullOrWhiteSpace(lcNombreMonedaEmpresa) ? lcNombreMonedaEmpresa : loDivisaEmpresa._NombreMoneda.Trim();
                            lcNombreMonedaEmpresa = !string.IsNullOrWhiteSpace(lcNombreMonedaEmpresa) ? lcNombreMonedaEmpresa : loDivisaEmpresa._Abrev.Trim();
                            this._oRemesa._Error_Message_LineaRemesa = "No se puede añadir la previsión indicada a la remesa. Solo se pueden añadir previsiones de divisa " + lcNombreMonedaEmpresa;
                            loDivisaEmpresa = null;
                            return false;
                        }


                        // Si la previsión está incluida en un pagaré no permito remesarla.
                        //
                        if (!string.IsNullOrWhiteSpace(toPrevisionPago._Num_Pag))
                        {
                            this._oRemesa._Error_Message_LineaRemesa = "La previsión de pago introducida ya está incluida en un pagaré (" + toPrevisionPago._Num_Pag.Trim() + ")." + Environment.NewLine + Environment.NewLine +
                                                                       "Para gestionar el pago deberá hacerlo desde el pagaré.";
                            return false;
                        }

                        // Si la previsión está incluida en una agrupación no permito remesarla.
                        //
                        if (!string.IsNullOrWhiteSpace(toPrevisionPago._Refundir))
                        {
                            this._oRemesa._Error_Message_LineaRemesa = "La previsión de pago introducida está incluida en una agrupación de previsiones (" + toPrevisionPago._Refundir.Trim() + ")." + Environment.NewLine + Environment.NewLine +
                                                                       "No se puede agregar esta previsión.";
                            return false;
                        }

                        // Antes de añadir la previsión de pago a la remesa reviso si la cuenta del banco tiene declarado límite de crédito.
                        // Avisaremos caso de que la remesa vaya a sobrepasar este importe al añadir la previsión y el usuario decidirá
                        // si aún así continua añadiendo la previsión o no.
                        //
                        bool llContinuar = this._oRemesa._RevisarCreditoEntidad(-this._Importe + toPrevisionPago._Importe, true);
                        if (!llContinuar)
                            return false;
                    }

                    return true;
                }


                private void rellenarLineaDatosPrevisionPago(PrevisionPago toPrevisionPago)
                {
                    this._Periodo = toPrevisionPago._Ejercicio;
                    this._Emision = toPrevisionPago._Fecha_Emision;
                    
                    this._Pendiente = toPrevisionPago._Pendiente;

                    this._Vencim = toPrevisionPago._Fecha_Vencim;
                    this._Concepto = toPrevisionPago._Concepto;
                    this._Importe = toPrevisionPago._Importe;
                    this._ImporteDiv = toPrevisionPago._ImporteDiv;
                    this._Divisa = toPrevisionPago._Divisa;
                    this._Cambio = toPrevisionPago._Cambio;
                    this._FecReme = toPrevisionPago._Fecha_Remesa;
                    this._NumBanco = toPrevisionPago._Num_Banco;

                    this._oRemesa._Totalizar();

                    // Guardo inmediatamente el registro en la base de datos para que actualice el nº de remesa en la previsión.
                    //
                    this._oParent._SaveItem(this);

                    return;
                }
            }
        }
    }


    public class DocPrintRemesaBancariaPago : DocPrintRemesaBancaria
    {
        #region CONSTRUCTORES


        public DocPrintRemesaBancariaPago(IDocumentoImprimible loDocumentoImprimible) 
            : base(loDocumentoImprimible)
        {
            // Rellenar los parámetros de configuración que son específicos sólamente de impresión de remesa bancaria de pago con su valor por defecto.
            //
            this.configuracionInicialImpRemPago();
        }


        #endregion CONSTRUCTORES


        #region MÉTODOS PRIVADOS

        public override UserControl _UserControlAdicional
        {
            get
            {
                UserControls.OpcionesImpresionRemesa loUserControl = (UserControls.OpcionesImpresionRemesa)base._UserControlAdicional;
                loUserControl._TipoPagoCobro = UserControls.OpcionesImpresionRemesa.TipoPagoCobro.Pago;

                return loUserControl;
            }
            set
            {
                base._UserControlAdicional = value;
            }
        }

        private void configuracionInicialImpRemPago()
        {
            return;
        }


        #endregion MÉTODOS PRIVADOS
    }
}