clsRetencion.cs

using System;
using System.Collections.Generic;
using System.Text;
using sage.ew.cliente;
using sage.ew.docsven;
using sage.ew.db;
using sage.ew.functions;
using System.Data;
using System.Windows.Forms;
using sage.ew.interficies;
using sage.ew.articulo;
using sage.ew.global;
using System.Linq;
using System.ComponentModel;
using sage.ew.ewbase;
using sage.ew.global.Diccionarios;

namespace sage.ew.docsven
{
    public enum TipoRetencionVentas 
    { 
        Fiscal, 
        NoFiscal 
    };
    
    public class Retencion : IDisposable
    {
        #region PROPIEDADES PÚBLICAS
        

        [DefaultValue(false)]
        public bool _SobreBase
        {
            get { return _lSobreBase; }
            set { _lSobreBase = value; }
        }
        private bool _lSobreBase = false;


        [DefaultValue(0.0)]
        public decimal _ImporteRetencion
        {
            get { return _nImporteRetencion; }
            set { _nImporteRetencion = value; }
        }
        private decimal _nImporteRetencion = 0.0M;


        [DefaultValue(0.0)]
        public decimal _RetencionPorcen
        {
            get { return _nRetencionPorcen; }
            set { _nRetencionPorcen = value; }
        }
        private decimal _nRetencionPorcen = 0.0M;


        [DefaultValue("")]
        public string _RetencionTipo
        {
            get { return _cRetencionTipo; }
            set { _cRetencionTipo = value; }
        }
        private string _cRetencionTipo = "";
        

        [DefaultValue(TipoRetencionVentas.Fiscal)]
        public TipoRetencionVentas _TipoRetFiscNoFisc
        {
            get { return _eTipoRetFiscNoFisc; }
            set { _eTipoRetFiscNoFisc = value; }
        }
        private TipoRetencionVentas _eTipoRetFiscNoFisc = TipoRetencionVentas.Fiscal;


        [DefaultValue(false)]
        public bool _HayRetencion
        {
            get { return _lHayRetencion; }
            set { _lHayRetencion = value; }
        }
        private bool _lHayRetencion = false;


        #endregion PROPIEDADES PÚBLICAS


        #region PROPIEDADES PRIVADAS


        private dynamic _oDocRef = null;


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

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


        private int _lnDecimales = Convert.ToInt32(EW_GLOBAL._GetVariable("wn_decimales"));


        private bool _lPverde = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_pverde"));


        private bool _lRecivainc = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_recivainc"));


        private bool _lDivisa = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_divisaventa"));


        private Dictionary<String, DataTable> _DicRetEmpCli = new Dictionary<String, DataTable>();


        private Dictionary<String, DataTable> _DicRetSoporFact = new Dictionary<String, DataTable>();


        private Dictionary<String, Dictionary<string,object>> _DicIvareperFact = new Dictionary<String, Dictionary<string, object>>();

        private bool disposedValue = false;  


        #endregion PROPIEDADES PRIVADAS


        #region CONSTRUCTORES


        public Retencion()
        {
            this._lSobreBase = false;
            this._nImporteRetencion = 0.0M;
            this._nRetencionPorcen = 0.0M;
            this._cRetencionTipo = "";
            this._eTipoRetFiscNoFisc = TipoRetencionVentas.Fiscal;
            this._lHayRetencion = false;
        }


        #endregion CONSTRUCTORES


        #region MÉTODOS PÚBLICOS


        public decimal _Calcular_Retencion(dynamic toDocumento, Dictionary<string,object> toCondicionesRetencion = null)
        {
            decimal lnPrcReten = 0.0M, lnTotalBase = 0.0M, lnTotalDocumento = 0.0M, lnTotalPronto = 0.0M, lnImportePortes = 0.0M,  lnImporteDivPortes = 0.0M, lnImportePortesIva = 0.0M, lnImporteDivPortesIva = 0.0M;
            string lcEmpresa = "", lcDivisa = "", lcCliente = "", lcIva_Portes = "", lcTipoIva_Pverde = "";
            bool llSobreBase = false, llRetNoFisc = false, llIncluirProntoPagoPortes = false, llRecEquivCliente = false;
            int  lnDecimalesMonedaDocu=0;

            this._oDocRef = toDocumento;

            Cliente loCliente;
            DataTable ldtReter = new DataTable(), ldtRetMp = new DataTable();
            ewMascara loMascaraPorcent = new ewbase.ewMascara(KeyDiccionarioMascara.wc_tpc);

            // Inicializamos propiedades internas
            this._lHayRetencion = false;
            this._lSobreBase = false;
            this._nImporteRetencion = 0.0M;
            this._cRetencionTipo = "";
            this._nRetencionPorcen = 0.0M;
            this._eTipoRetFiscNoFisc = TipoRetencionVentas.Fiscal;

                lcEmpresa = toDocumento._Empresa;
            lcCliente = toDocumento._Cabecera._oCliente._Codigo;
            lcDivisa = toDocumento._Cabecera._Divisa;
            
            // Total base imponible del documento
            lnTotalBase = toDocumento._Pie._TotalBase;

            // Total pronto pago del documento
            lnTotalPronto = toDocumento._Pie._TotalPP;

            // Total final
            lnTotalDocumento = toDocumento._Pie._TotalDocumento - toDocumento._Pie._TotalRecFinan;  // PE-76353. Restar importe del recargo financiero

            // Si la retencion es fiscal el calculo del total retencion se hace linea
            // a linea recorriendo el documento pues pueden haber articulos que tengan
            // retencion o no. Los suplidos ya no los tiene en cuenta en este cálculo
            //
            // Y si la retencion es no fiscal en el _TotalDOcumento, en el momento de llamar
            // desde el _Calcular_Iva() a este metodo en el que estamos, aun no se han
            // añadido al _TotalDocumento por que se hace al final de todo, por tanto,
            // aqui no hay que restar los suplidos del total documento.

            // Si el documento tiene valor 0 no hace falta que perdamos más el tiempo
            if (lnTotalBase == 0 && lnTotalDocumento == 0)
                return 0.0M;

            // Decimales para redondeo en la moneda del documento
            lnDecimalesMonedaDocu = toDocumento._Cabecera._oDivisa._Decimales;

            // Detectar con qué tipo de retención trabaja el cliente: no fiscal, fiscal o sin retención de ningún tipo.

            // Task 131967, optimizacion de la clase retencoin, nos aprovechamos del objeto de Cliente existente en la cabecera del documento, no hace falta crear un objeto nuevo.
            // loCliente = new Cliente(lcCliente);
            loCliente = toDocumento._Cabecera._oCliente;

            // CCR 205453 - Si tenemos porcentaje de retención no fiscal, calculamos la retención, aunque en la ficha esté desmarcado
            if ( ( (toDocumento._TipoDocumento == eTipoDocumento.FacturaVenta || toDocumento._TipoDocumento == eTipoDocumento.Factura) && 
                    !string.IsNullOrWhiteSpace(toDocumento._Asi)) || 
                 ( (toDocumento._TipoDocumento == eTipoDocumento.FacturaVenta || toDocumento._TipoDocumento == eTipoDocumento.Factura 
                   || toDocumento._TipoDocumento == eTipoDocumento.AlbaranVenta) && toDocumento._Cabecera._TpcRetNoFi != 0 ) )
                // CCR186750
                // Albarán de venta facturado y contabilizado (formulario albarán de venta o TPV consultando albarán de venta),
                // o factura de venta contabilizada (formulario factura de venta, consultando documento factura).
                //
                // Podría ser que el documento fuese facturado con retención no fiscal, pero en este momento el cliente ya no tenga la marca
                // de retención no fiscal en ficha.
                //
                // Por tanto, en facturas, siempre que esten contabilizadas, se aplicará o no retención no fiscal de cliente únicamente en
                // función de si el campo Tpcretnofi de C_ALBVEN esté declarado o no, no miramos marca de aplicar retención de la ficha del
                // cliente para nada.
                //
                // Recordar que en depósito, pedido y presupuesto no tenemos este campo en cabecera (._Cabecera._TpcRetNoFi) por que
                // tampoco existe en la tabla de cabecera respectiva del documento.
                //
                llRetNoFisc = toDocumento._Cabecera._TpcRetNoFi != 0 ;
            else
                // En factura de venta no contabilizada, albarán de venta pendiente y resto de documentos de venta, si se aplica o no retención
                // fiscal dependerá únicamente de la marca que tenga el cliente en su ficha.
                //
                // Si es un documento factura y no está contabilizada, funciona como si fuese un documento de venta tipo albarán, se aplicará
                // retención no fiscal o no en función de lo que tenga el cliente definido en su ficha, aunque haya un _TpcRetNofi != 0 en cabecera.
                // Que haya un _TpcRetNofi != 0 y un _ASI="" se podria dar si contabilizan la factura teniendo retencion definida en ficha, le
                // quitan la retencion en ficha, y descontabilizan la factura, en este caso, manda lo que haya en ficha, funciona de esta forma
                // tanto si es retención fiscal como si es retención no fiscal.
                //
                llRetNoFisc = loCliente._RetencionNoFiscal;

            llRecEquivCliente = loCliente._Recargo;
            
            if (llRetNoFisc)
            {
                decimal lnCuotaIvaNoSujeto = 0.0M;

                // Retención NO FISCAL
                //
                this._lHayRetencion = true;
                if (toDocumento._TipoDocumento == eTipoDocumento.AlbaranVenta || toDocumento._TipoDocumento == eTipoDocumento.FacturaVenta || toDocumento._TipoDocumento == eTipoDocumento.Factura) 
                {
                    // Si estoy en un albarán de venta (facturado o no), o factura (contabilizada o no), el % de retención no fiscal está guardado en
                    // la cabecera.
                    //
                    lnPrcReten = toDocumento._Cabecera._TpcRetNoFi;
                }                
                else
                {
                    // Si estoy en un documento de venta que no es albarán ni factura, el % de retención no fiscal no está guardado en la cabecera, lo 
                    // cogemos de la ficha del cliente.
                    //
                    lnPrcReten = loCliente._RetencionNoFiscalTPC;
                }
                this._lSobreBase = (Convert.ToInt32(loCliente._Campo("modretnofi")) == 1);

                // Control label de retención en el formulario
                // 

                // Obtener el nº de tipos de iva sujetos.
                //
                int lnTiposIvaSujetos = toDocumento._NumTiposIvaSujetos;

                // Obtener el nº de tipos de iva no sujetos.
                //
                int lnTiposIvaNoSujetos = toDocumento._NumTiposIvaNoSujetos;

                // Cálculo del importe de la retención y relleno los 3 campos que interesa guardar.
                if (this._lSobreBase)
                {
                    // En _Pie._TotalBase esta la base imponible antes de pronto pago (suma linias + importe portes si son antes pronto pago), pero la retención no fiscal sobre la base se calcula sobre la suma
                    // de las bases de los tipos de IVA y allí puede haber además los portes si son despues de pronto pago los cuales en este caso no estan contemplados en _Pie._TotalBase, hay que añadirlos pues.
                    //
                    // Si los portes son antes de pronto pago ya estan contemplados en _Pie._TotalBase
                    //
                    // Si los portes son IVA incluido en ningún caso se tienen en cuenta cara el cálculo de la retención no fiscal sobre base (al igual que FOX).
                    // Recordar: documento con iva incluido, los portes siempre son despues de printo pago y iva incluido y el usuairo no puede modificar esta configuración
                    //           documenbto sin iva incluido, los portes se pueden escoger antes pronto pago (siempre seran sin iva inc) o despues pronto pago (el usuario escoge si son ivainc o no).
                    //
                    // Si hubiese recargo financiero, tampoco está contemplado en _Pie._TotalBase pero no importa pues la retención no fiscal sobre base no debe tener en cuenta este recargo financiero, no hace falta hacer nada.
                    if ((toDocumento._Pie._Portes._Importe != 0 || toDocumento._Pie._Portes._ImporteDivisa != 0) && toDocumento._Pie._Portes._Incluir_ProntoPago == false && toDocumento._Pie._Portes._Iva_Incluido == false)
                    {
                        lnImportePortes = !string.IsNullOrWhiteSpace(toDocumento._Cabecera._Divisa) && toDocumento._Cabecera._Divisa != this._lcMonedaEmpresa ? toDocumento._Pie._Portes._ImporteDivisa : toDocumento._Pie._Portes._Importe;

                        // Añado a la base de cálculo los portes que son después de pronto pago, al ser NO IVA incluido ya está bien, no hay que hacer nada más.
                        lnTotalBase += lnImportePortes;
                    }
                    
                    // Bug188198 y CCR207431 
                    //
                    // Si tenemos tipos de IVA sujetos y no sujetos en el mismo documento, la retencion no fiscal se calcula sobre los tipos de
                    // IVA sujetos solamente, se ignoran los tipos de IVA no sujetos.
                    // Si solo tenemos tipos de IVA sujetos en el documento, la retencion no fiscal se calcula sobre esos tipos de IVA sujetos.
                    // Si solo tenemos tipos de IVA NO sujetos en el documento, la retencion no fiscal se calcula sobre esos tipos de IVA NO sujetos.
                    // 
                    if (lnTiposIvaSujetos > 0 && lnTiposIvaNoSujetos > 0)
                        lnTotalBase -= toDocumento._Pie._ObtenerBaseIvaNoSujeto(out lnCuotaIvaNoSujeto);

                    this._nImporteRetencion = FUNCTIONS._Round((lnTotalBase - lnTotalPronto) * lnPrcReten / 100, lnDecimalesMonedaDocu);
                }
                else
                {
                    // Bug188198 y CCR207431 
                    //
                    // Si tenemos tipos de IVA sujetos y no sujetos en el mismo documento, la retencion no fiscal se calcula sobre los tipos de
                    // IVA sujetos solamente, se ignoran los tipos de IVA no sujetos.
                    // Si solo tenemos tipos de IVA sujetos en el documento, la retencion no fiscal se calcula sobre esos tipos de IVA sujetos.
                    // Si solo tenemos tipos de IVA NO sujetos en el documento, la retencion no fiscal se calcula sobre esos tipos de IVA NO sujetos.
                    // 
                    if (lnTiposIvaSujetos > 0 && lnTiposIvaNoSujetos > 0)
                    {
                        lnTotalDocumento -= toDocumento._Pie._ObtenerBaseIvaNoSujeto(out lnCuotaIvaNoSujeto);
                        lnTotalDocumento -= lnCuotaIvaNoSujeto;
                    }
                    this._nImporteRetencion = FUNCTIONS._Round(lnTotalDocumento * lnPrcReten / 100, lnDecimalesMonedaDocu);
                }

                this._cRetencionTipo = $"{(this._lSobreBase ? "Reten.No Fisc./Base" : "Reten.No Fisc./TotalFra.")} ({ loMascaraPorcent.StringFormatNet(lnPrcReten)})";
                this._nRetencionPorcen = lnPrcReten;
                this._eTipoRetFiscNoFisc = TipoRetencionVentas.NoFiscal;

                // Si la retención es NO FISCAL ya hemos acabado, no hace falta hacer nada más.
                return this._nImporteRetencion;
            }

            // A partir de aquí ya estamos siempre en el caso de retención FISCAL

            // Caso de ser RETENCION FISCAL, hemos de tener en cuenta en el cálculo de las retenciones solamente los articulos que no tienen marcado en su ficha "Sin Retención", tener en cuenta también si hay portes, pronto pago, etc.
            // Para ello nos recorreremos todas las lineas del documento e iremos acumulando importe de retención teniendo en cuenta todo lo anterior comentado (portes, pronto pago, marca "sin retencion" en ficha artículo, etc.)
            
            // En este diccionario obtendremos el % de retencion a aplicar (o aplicado caso de ser factura en el momento de ser facturado), el modo de retención (sobre base/total factura), si el documento tiene recargo de equivalencia, etc.
            Dictionary<string, object> loDicCurReter;
            if (toCondicionesRetencion != null)
                loDicCurReter = toCondicionesRetencion;
            else
            {
                loDicCurReter = new Dictionary<string, object>();
                loDicCurReter = this.Obtener_Condiciones_Retencion(toDocumento);
            }

            lnPrcReten = loDicCurReter.Count > 0 ? Convert.ToDecimal(loDicCurReter["retencion"]) : 0;

            if (loDicCurReter.Count == 0 || lnPrcReten == 0)  
            {
                // Task 170566
                // El cliente podria tener retencion en ficha pero si el tipo de retención es del tipo "Aplicar % en documentos", el usuario podría 
                // cambiar el % en el documento y dejar 0 % de retención con lo que es lo mismo que no tener retención. De ahí que hayamos añadido 
                // la condición " || lnPrcReten == 0) "
                //

                // No hay retención, rellenamos los campos y salimos.
                this._lHayRetencion = false;
                this._lSobreBase = false;
                this._nImporteRetencion = 0.0M;
                this._cRetencionTipo = "";
                this._nRetencionPorcen = 0.0M;
                this._eTipoRetFiscNoFisc = TipoRetencionVentas.Fiscal;
                return 0.0M;
            }

            // Obtenidas las condiciones vamos a iterar por las lineas y en función de lo que vayamos encontrando en cada linea acumularemos retencion o no
            llSobreBase = Convert.ToBoolean(loDicCurReter["modo_ret"]);

            // Si no se cumple esta esta condición ya no entraremos al bucle de linea a linea para calcular la retencion solo de las lineas que la tengan.
            if ( (lnTotalBase != 0 || lnTotalDocumento != 0) && lnPrcReten != 0)
            {
                string lcNumeroAlb = new string('@', 10);
                string lcLetraAlb = new string('@', 2);

                decimal lnTotalRetencion = 0.0M;

                // Recorremos todas las lineas del documento, podemos estar en un documento factura que tiene datos de varios albaranes de venta, en un documento factura que tenga solo un albarán, en un documento albarán facturado, tenemos varios
                // casos.
                // Esencialmente, hay 2 casos diferentes, que haya más de un albarán de venta en el documento o solo uno. Es importante este aspecto pues el registro de portes va asociado al albarán y no a la factura, por lo que caso de que estamos
                // en una factura de venta con varios albaranes, tendremos que tener en cuenta de a cada cambio de albarán hay que revisar el registro de portes.
                foreach (Docsven.IDocVentaLin lin in toDocumento._Lineas)
                {
                    if (lin._Numero != lcNumeroAlb || lin._Letra != lcLetraAlb)
                    {
                        // Cambio del nº de albarán, si estamos en un albarán de venta este número será siempre el mismo pero si estamos en un documento de tipo factura irá cambiando por que podrá haber más de un albarán y a cada documento
                        // iremos redondeando el total retencion acumulado a los decimales de la moneda.
                        lnTotalRetencion = FUNCTIONS._Round(lnTotalRetencion, lnDecimalesMonedaDocu);

                        lnImportePortes = 0.0M;
                        lnImporteDivPortes = 0.0M;

                        this.Obtener_Importe_Portes(lcEmpresa, lin._Numero, lin._Letra, toDocumento, ref lnImportePortes, ref lnImporteDivPortes, ref lnImportePortesIva, ref lnImporteDivPortesIva, ref llIncluirProntoPagoPortes, ref lcIva_Portes);

                        // Si tenemos portes vamos a calcular la retención respectiva.
                        if (lnImportePortes != 0.0M)
                            lnTotalRetencion += this.Retencion_Linea("", lcIva_Portes, lnImportePortes, lnImporteDivPortes, lnImportePortesIva, lnImporteDivPortesIva, 0.0M, "", llRecEquivCliente, loDicCurReter, toDocumento, true, llIncluirProntoPagoPortes, null);

                        lcNumeroAlb = lin._Numero;
                        lcLetraAlb = lin._Letra;
                    }

                    // Calculamos la retención que le toca a la linea del documento en el que estamos.
                    // No procesamos lineas de notas ni linias de suplidos.
                    if (!string.IsNullOrWhiteSpace(lin._TipoIva) && !lin._Suplido)
                    {
                        lcTipoIva_Pverde = "";
                        if (this._lPverde && lin._PuntoVerde != 0)
                            lcTipoIva_Pverde = !string.IsNullOrWhiteSpace(lin._TipoIvaPV) ? lin._TipoIvaPV : lin._TipoIva;

                        Articulo loArticulo = lin._oArticulo;
                        lnTotalRetencion += this.Retencion_Linea(lin._Articulo, lin._TipoIva, lin._Importe, lin._ImporteDivisa, lin._ImporteIva, lin._ImporteDivisaIva, lin._PuntoVerde, lcTipoIva_Pverde, llRecEquivCliente, loDicCurReter, toDocumento, false, true, loArticulo);
                        // Vacio la memoria que haya ocupado la utilización del objeto lin._oArticulo al pasarlo como parámetro en la llamada anterior.
                        lin._oArticulo = null;
                    }
                }
                
                lnTotalRetencion = FUNCTIONS._Round(lnTotalRetencion, lnDecimalesMonedaDocu);

                this._lSobreBase = llSobreBase;
                this._nImporteRetencion = lnTotalRetencion;
                this._cRetencionTipo = $"{(this._lSobreBase ? "Reten./Base" : "Reten./TotalFra.")} ({loMascaraPorcent.StringFormatNet(lnPrcReten)})";
                this._nRetencionPorcen = lnPrcReten;
                this._lHayRetencion = true;
                this._eTipoRetFiscNoFisc = TipoRetencionVentas.Fiscal;
            }
            else
            {
                // No hay retención
                this._lHayRetencion = false;
                this._cRetencionTipo = "";
                this._nRetencionPorcen = 0.0M;
                this._nImporteRetencion = 0.0M;
                this._eTipoRetFiscNoFisc = TipoRetencionVentas.Fiscal;
                this._lSobreBase = false;
            }

            // Retornamos el importe correspondiente a la retención.
            return this._nImporteRetencion;
        }


        public virtual bool _Calcular_Retencion(dynamic toDocumento, out decimal tnImporteRetencion, out decimal tnPorcentajeRetencion, out string tcTipoRetencion)
        {
            tnImporteRetencion = this._Calcular_Retencion(toDocumento); //Invoco a la función original

            tnPorcentajeRetencion = this._nRetencionPorcen;     
            tcTipoRetencion = this._cRetencionTipo;     

            return this._lHayRetencion;
        }


        public virtual void _Control_Label_Retencion(dynamic toFormPare, bool tlHayRetencion, bool tlFiscal = true, decimal tnTpc = 0)
        {
            this._Control_Label_Retencion(toFormPare, tlHayRetencion, null, tlFiscal, tnTpc);

            return;
        }


        public virtual void _Control_Label_Retencion(dynamic toFormPare, bool tlHayRetencion, bool? tlSobreBase, bool tlFiscal = true, decimal tnTpc = 0)
        {
            string lcText = "";
            Control[] loControls = toFormPare.Controls.Find("lblRetencion", true);
            if (loControls.Length > 0)
            {
                if (tlFiscal)
                    lcText = "Ret.Fiscal";
                else
                    lcText = "Ret. No Fiscal";

                lcText += " (" + tnTpc.ToString().Trim() + "%" + (tlSobreBase != null ? ((bool)tlSobreBase ? " Sb" : " St") : "") + ")";

                loControls[0].Visible = tlHayRetencion;
                loControls[0].Text = lcText;
            }
            loControls = null;

        }


        public void Dispose()
        {
            // No cambie este código. Coloque el código de limpieza en el anterior Dispose(colocación de bool).
            Dispose(true);
            // para que el recolector de elementos no utilizados no llame al finalizador del objeto
            GC.SuppressFinalize(this);
        }


        public void _ReleaseQueryCaches()
        {
            foreach (KeyValuePair<string,DataTable> pair in this._DicRetEmpCli)
            {
                FUNCTIONS._DisposeDatatable(pair.Value);
            }

            foreach (KeyValuePair<string, DataTable> pair in this._DicRetSoporFact)
            {
                FUNCTIONS._DisposeDatatable(pair.Value);
            }

            foreach (KeyValuePair<string,Dictionary<string,object>> pair in this._DicIvareperFact)
            {
                pair.Value.Clear();
            }

            this._DicRetEmpCli.Clear();
            this._DicRetSoporFact.Clear();
            this._DicIvareperFact.Clear();
            return;
        }


        #endregion MÉTODOS PÚBLICOS


        #region MÉTODOS PRIVADOS


        private void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    // Vaciar las caches de consultas.
                    //
                    this._ReleaseQueryCaches(); 
                }
                disposedValue = true;
            }
        }


        private DataTable _Informacion_RetEmpCli(string tcEmpresa, string tcCliente)
        {
            DataTable ldtDataTable = new DataTable();

            if (string.IsNullOrWhiteSpace(tcEmpresa) || string.IsNullOrWhiteSpace(tcCliente))
                return ldtDataTable;

            if (!this._DicRetEmpCli.ContainsKey(tcEmpresa+"/"+tcCliente))
            {
                // CCR190539, caso estar consultando un documento de un ejercicio anterior desde otro ejercicio.
                string ldBdGestion = "GESTION";
                if (!string.IsNullOrWhiteSpace(this._oDocRef._EjercicioDB) && this._oDocRef._EjercicioDB.Trim() != "GESTION" &&
                     this._oDocRef._EjercicioDB.Trim() != this._cAny.Trim())
                    ldBdGestion = this._oDocRef._EjercicioDB.Trim();

                // Recordar que a pesar de que a partir de Octubre del 2020 el % de retención fiscal viene en un campo del pie del documento
                // hemos de hacer esta consulta para averiguar si la retención es sobre base o sobre total, asi como verifivar que la retención
                // en la empresa esté activa, y ninguna de las dos cosas anteriores se guarda en el documento.
                //
                string lcSql = "SELECT a.RETENCION, b.MODO_RET, " + DB.SQLFalse() + " AS RECARGO, " + DB.SQLString("", 2) + " AS TIPO_IVA " +
                               "FROM " + DB.SQLDatabase(ldBdGestion, "TIPO_RET") + " a " +
                               "INNER JOIN " + DB.SQLDatabase(ldBdGestion, "RET_EMP") + " b ON a.CODIGO=b.TIPO_RET " +
                               "WHERE b.empresa = " + DB.SQLString(tcEmpresa) + " and  b.cuenta = " + DB.SQLString(tcCliente);

                DB.SQLExec(lcSql, ref ldtDataTable);

                this._DicRetEmpCli.Add(tcEmpresa+"/"+tcCliente, ldtDataTable);
            }

            return this._DicRetEmpCli[tcEmpresa + "/" + tcCliente];
        }


        private DataTable _Informacion_RetSoporFact(dynamic toDocumento, string tcFactura)
        {
            DataTable ldtDataTable = new DataTable();
            if (_Informacion_RetSoporFactContabilizada(toDocumento, ref ldtDataTable))
                return ldtDataTable;
            else 
                return _Informacion_RetSoporFactTabla(toDocumento._Empresa, tcFactura);
        }


        private bool _Informacion_RetSoporFactContabilizada(dynamic toDocumento, ref DataTable tdtDataTable)
        {
            // Para saber si estamos en un DTS mirar si el campo ASI tiene valor "CONTABILIZADA"
            if (!(toDocumento is ewDocVentaFRA) || toDocumento._Asi.Trim() != "CONTABILIZADA")
                return false;

            // Obtener los albaranes de la factura
            Dictionary<string, sage.ew.docventatpv.ewDocVentaTPV> _dicAlbaranes = toDocumento._dicAlbaranes;
            if (_dicAlbaranes == null || _dicAlbaranes.Count == 0)
                return false;

            // Añadir las columnas 
            tdtDataTable.Columns.Add("tipo_ret", typeof(decimal));
            tdtDataTable.Columns.Add("modo_ret", typeof(Int32));

            // Obtener la información de la retención
            DataRow ldrRow =  tdtDataTable.NewRow();
            ldrRow["tipo_ret"] = ((sage.ew.docventatpv.ewDocVentaTPV)_dicAlbaranes.First().Value)._Pie._RetencionPorcen;
            ldrRow["modo_ret"] = ((sage.ew.docventatpv.ewDocVentaTPV)_dicAlbaranes.First().Value)._Pie._RetencionModo;
            tdtDataTable.Rows.Add(ldrRow);

            return true;
        }


        private DataTable _Informacion_RetSoporFactTabla(string tcEmpresa, string tcFactura)
        {
            DataTable ldtDataTable = new DataTable();

            if (string.IsNullOrWhiteSpace(tcEmpresa) || string.IsNullOrWhiteSpace(tcFactura))
                return ldtDataTable;

            if (!this._DicRetSoporFact.ContainsKey(tcEmpresa + "/" + tcFactura))
            {
                // CCR190539, caso estar consultando un documento de un ejercicio anterior desde otro ejercicio.
                string ldBdGestion = "GESTION";
                if (!string.IsNullOrWhiteSpace(this._oDocRef._EjercicioDB) && this._oDocRef._EjercicioDB.Trim() != "GESTION" &&
                     this._oDocRef._EjercicioDB.Trim() != this._cAny.Trim())
                    ldBdGestion = this._oDocRef._EjercicioDB.Trim();

                string lcSql = "SELECT a.* " +
                               "FROM " + DB.SQLDatabase(ldBdGestion, "RETSOPOR") + " a " +
                               "INNER JOIN " + DB.SQLDatabase(ldBdGestion, "TIPO_RET") + " b ON a.CODIGO_RET=b.CODIGO " +
                               "WHERE a.empresa = " + DB.SQLString(tcEmpresa) + " and a.numfra = " + DB.SQLString(tcFactura);
                DB.SQLExec(lcSql, ref ldtDataTable);

                this._DicRetSoporFact.Add(tcEmpresa + "/" + tcFactura, ldtDataTable);
            }

            return this._DicRetSoporFact[tcEmpresa + "/" + tcFactura];
        }


        private Dictionary<string, object> _Informacion_IvareperFact(string tcEmpresa, string tcFactura)
        {
            Dictionary<string, object> laCampos = new Dictionary<string, object>();

            if (string.IsNullOrWhiteSpace(tcEmpresa) || string.IsNullOrWhiteSpace(tcFactura))
            {
                laCampos.Add("tipo_iva", "");
                laCampos.Add("recargo", false);
                return laCampos;
            }

            if (!this._DicIvareperFact.ContainsKey(tcEmpresa + "/" + tcFactura))
            {
                // Bug 133253, ojo por que en un albarán facturado el cliente de IVAREPER podria ser diferente si el cliente del albarán tiene cliente factura.  Y podríamos tener el caso
                // de que el cliente del albarán no tenga recargo equivalencia y el cliente factura si lo tenga lo cual haria variar las condiciones, nos ahorramos el filtro por cliente
                // para que encuentre siempre el registro de IVAREPER
                //loDicIvareper = DB.SQLValor("IVAREPER", new String[] { "empresa", "cuenta", "numfra" }, new string[] { lcEmpresa, lcCliente, lcNumFra }, new string[] { "tipo_iva", "recargo" });

                laCampos = DB.SQLValor("IVAREPER", new String[] { "empresa", "numfra" }, new string[] { tcEmpresa, tcFactura }, new string[] { "tipo_iva", "recargo" });

                this._DicIvareperFact.Add(tcEmpresa + "/" + tcFactura, laCampos);
            }

            return this._DicIvareperFact[tcEmpresa + "/" + tcFactura];
        }


        private void Obtener_Importe_Portes(string tcEmpresa, string tcNumero, string tcLetra, dynamic toDocumento, ref decimal tnImportePortes, ref decimal tnImporteDivPortes, ref decimal tnImportePortesIva, ref decimal tnImporteDivPortesIva, ref bool tlIncluirProntoPagoPortes, ref  string tcIva_Portes)
        {
            bool llIvaInc = false;

            if (  toDocumento._TipoDocumento == eTipoDocumento.Factura ||
                  toDocumento._TipoDocumento == eTipoDocumento.FacturaVenta ||
                ( toDocumento._TipoDocumento == eTipoDocumento.AlbaranVenta && !string.IsNullOrWhiteSpace(toDocumento._Cabecera._Factura) ) )
            {
                // Si es un documento de factura vamos a buscar los portes a la tabla, portes del albarán que estamos procesando
                Dictionary<string, object> loDicPortes = new Dictionary<string, object>();
                loDicPortes = DB.SQLREGValor("portes", new string[] { "empresa", "albaran", "letra"  }, new string[] { tcEmpresa, tcNumero, tcLetra });

                bool llInc_Fra = Convert.ToBoolean(loDicPortes["inc_fra"]);
                if (llInc_Fra)
                {
                    tlIncluirProntoPagoPortes = Convert.ToBoolean(loDicPortes["inc_pp"]);
                    llIvaInc = Convert.ToBoolean(loDicPortes["iva_inc"]);
                    tcIva_Portes = Convert.ToString(loDicPortes["tipo_iva"]);

                    // Task 131967, optimizacion, nos aprovechamos del diccionario de tipos de iva del documento y nos ahorramos probablemente la consulta.
                    // TipoIVA loTipoIva = new TipoIVA();
                    // loTipoIva._Codigo = tcIva_Portes;
                    // decimal lnTipoIva = 1 + (loTipoIva._IVA / 100);

                    decimal lnTipoIva = 1 + (toDocumento._Informacion_Tipo_Iva(tcIva_Portes)["iva"] / 100);

                    if (llIvaInc)
                    {
                        tnImportePortesIva = Convert.ToDecimal(loDicPortes["importe"]);
                        tnImporteDivPortesIva = Convert.ToDecimal(loDicPortes["importediv"]);

                        tnImportePortes = FUNCTIONS._Round(tnImportePortesIva / lnTipoIva, this._lnDecimales);
                        tnImporteDivPortes = FUNCTIONS._Round(tnImporteDivPortesIva / lnTipoIva, toDocumento._Cabecera._oDivisa._Decimales);
                    }
                    else
                    {
                        tnImportePortes = Convert.ToDecimal(loDicPortes["importe"]);
                        tnImporteDivPortes = Convert.ToDecimal(loDicPortes["importediv"]);

                        tnImportePortesIva = FUNCTIONS._Round(tnImportePortes * lnTipoIva, this._lnDecimales);
                        tnImporteDivPortesIva = FUNCTIONS._Round(tnImporteDivPortes * lnTipoIva, toDocumento._Cabecera._oDivisa._Decimales);
                    }
                }
                else
                {
                    tnImportePortesIva = 0;
                    tnImporteDivPortesIva = 0;
                    tnImportePortes = 0;
                    tnImporteDivPortes = 0;
                    tcIva_Portes = "";
                }
            }
            else
            {
                // Task 125111,125112: a partir de ahora todos los documentos de venta podran tener portes.
                if (toDocumento._TipoDocumento == eTipoDocumento.AlbaranVenta || toDocumento._TipoDocumento == eTipoDocumento.PedidoVenta || 
                    toDocumento._TipoDocumento == eTipoDocumento.PresupuestoVenta || toDocumento._TipoDocumento == eTipoDocumento.DepositoVenta )
                {
                    if (toDocumento._Pie._Portes._Incluir_EnFactura)
                    {
                        // Si es un documento de albarán vamos a buscar los portes al objeto
                        tlIncluirProntoPagoPortes = toDocumento._Pie._Portes._Incluir_ProntoPago;
                        llIvaInc = toDocumento._Pie._Portes._Iva_Incluido;

                        // Task 131967, optimizacion, nos aprovechamos del diccionario de tipos de iva del documento y nos ahorramos probablemente la consulta.
                        
                        // TipoIVA loTipoIva = new TipoIVA();
                        // loTipoIva._Codigo = tcIva_Portes;
                        // decimal lnTipoIva = 1 + (loTipoIva._IVA / 100);

                        tcIva_Portes = toDocumento._Pie._Portes._Tipo_Iva;
                        decimal lnTipoIva = 1 + (toDocumento._Informacion_Tipo_Iva(tcIva_Portes)["iva"] / 100);

                        if (llIvaInc)
                        {
                            tnImportePortesIva = toDocumento._Pie._Portes._Importe;
                            tnImporteDivPortesIva = toDocumento._Pie._Portes._ImporteDivisa;

                            tnImportePortes = FUNCTIONS._Round(tnImportePortesIva / lnTipoIva, this._lnDecimales);
                            tnImporteDivPortes = FUNCTIONS._Round(tnImporteDivPortesIva / lnTipoIva, toDocumento._Cabecera._oDivisa._Decimales);
                        }
                        else
                        {
                            tnImportePortes = toDocumento._Pie._Portes._Importe;
                            tnImporteDivPortes = toDocumento._Pie._Portes._ImporteDivisa;

                            tnImportePortesIva = FUNCTIONS._Round(tnImportePortes * lnTipoIva, this._lnDecimales);
                            tnImporteDivPortesIva = FUNCTIONS._Round(tnImporteDivPortes * lnTipoIva, toDocumento._Cabecera._oDivisa._Decimales);
                        }
                    }
                    else
                    {
                        tnImportePortesIva = 0;
                        tnImporteDivPortesIva = 0;
                        tnImportePortes = 0;
                        tnImporteDivPortes = 0;
                        tcIva_Portes = "";                    
                    }
                }
            }
        }


        private decimal Retencion_Linea(string tcArticulo, string tcTipoIva, decimal tnImporte, decimal tnImporteDivisa, decimal tnImporteIva, decimal tnImporteDivisaIva, decimal tnPuntoVerde, string tcTipoIva_Pverde, bool tlRecEquivCliente, Dictionary<string, object> toDicCurReter, dynamic toDocumento, bool tlLineaPortes = false, bool tlIncluirProntoPago = true, Articulo toArticulo = null)
        {
            string lcCliente = toDocumento._Cabecera._Cliente, lcTipo_Iva = "", lcTipoIvaReter = "";
            decimal lnPrcPronto = toDocumento._Pie._DtoPP, lnImportePverde = 0.0M, lnImportePVerdeIVA = 0.0M, lnImpPronto = 0.0M, lnRetencionLinea = 0.0M, lnPrcIvaPverde = 0.0M, lnRecarreg = 0.0M;
            decimal lnRetencionReter = 0.0M;
            bool ll_Divisa = false, llModo_RetReter = false, llRecargoReter = false;  

            ll_Divisa = this._lDivisa;
            llModo_RetReter = Convert.ToBoolean(toDicCurReter["modo_ret"]);
            lnRetencionReter = Convert.ToDecimal(toDicCurReter["retencion"]);
            lcTipoIvaReter = Convert.ToString(toDicCurReter["tipo_iva"]);
            llRecargoReter = Convert.ToBoolean(toDicCurReter["recargo"]);


            // Esto será útil en el momento que estemos acumulando la retención sobre los portes, si son después de pronto pago, aunque haya pronto pago, simularemos que no lo hay.
            if (!tlIncluirProntoPago)
                lnPrcPronto = 0;


            bool llAplicarRetencion = false;
            
            // Task 131967, optimización no utilizaré el objeto de tipos de iva sino que utilizaré el diccionario propio de tipos de IVA del documento.
            // TipoIVA loTipoIva = new TipoIVA();

            if (ll_Divisa == true && !string.IsNullOrWhiteSpace(toDocumento._Cabecera._Divisa) && toDocumento._Cabecera._Divisa != this._lcMonedaEmpresa)
                // Trabajamos con multidivisa y la moneda del documento es diferente de la moneda de la empresa
                ll_Divisa = true;
            else
                // No trabajamos con multidivisa, o trabajamos con multidivisa pero la moneda del documento es igual a la moneda de la empresa
                ll_Divisa = false;


            llAplicarRetencion = true;            

            if (!string.IsNullOrWhiteSpace(tcArticulo))
            {
                // Miramos si debe aplicarse retención al artículo.
                
                // Task 131967, optimizacion, no creamos el objeto Articulo sino que nos aprovechamos del que hay en la linea del documento.
                // Articulo loArticulo = new Articulo(tcArticulo);
                llAplicarRetencion = Convert.ToString(toArticulo._Campo("retencion")) != "N";
            }
            else
            {
                // Los artículos no codificados con importe siempre se aplicará retención.
                // Una linea de notas ya no llega a este metodo.
                // En particular cuando se llame a este método para el calculo de retencion sobre portes (se pasará artículo en blanco y tnImporte y tnImporteDIv)
            }

            // En el caso de que el documento tenga tipos de iva sujetos y no sujetos, solo los sujetos se utilizarán para
            // el cálculo de la retención.
            // 
            // Los tipos de iva no sujetos solo se utilizarán en el caso de que solo haya tipos de iva no sujetos en el documento.
            //
            // Mirar CCR203216 Y CCR184685
            //

            // Obtener el nº de tipos de iva sujetos.
            //
            int lnTiposIvaSujetos = toDocumento._NumTiposIvaSujetos;

            // Obtener el nº de tipos de iva no sujetos.
            //
            int lnTiposIvaNoSujetos = toDocumento._NumTiposIvaNoSujetos;


            bool llNoSujeto = toDocumento._Informacion_Tipo_Iva(tcTipoIva)["exento"];
            if (lnTiposIvaSujetos>0 && lnTiposIvaNoSujetos>0 && llNoSujeto)
                llAplicarRetencion = false;

            if (llAplicarRetencion)
            {
                lcTipo_Iva = "";
                if (llRecargoReter && llModo_RetReter == false)
                {
                    if (!string.IsNullOrWhiteSpace(tcTipoIva))
                        lcTipo_Iva = tcTipoIva;
                    else
                    {
                        if (!string.IsNullOrWhiteSpace(lcTipoIvaReter))
                            lcTipo_Iva = lcTipoIvaReter;
                        else
                            lcTipo_Iva = Convert.ToString(EW_GLOBAL._GetVariable("wc_tipo_iva"));
                    }
                }                

                // Importe de punto verde lineal
                lnImportePverde = this._lPverde && !string.IsNullOrWhiteSpace(tcArticulo) ? tnPuntoVerde : 0.0M;

                if (llModo_RetReter)
                {
                    // RETENCION SOBRE BASE
                    //
                    if (ll_Divisa)
                    {
                        // Moneda del documento diferente de la de la empresa.
                        //
                        lnImpPronto = 0.0M;
                        if (lnPrcPronto != 0)
                            lnImpPronto = tnImporteDivisa * lnPrcPronto / 100;

                        // En divisa diferente de la moneda de la empresa no hay punto verde.
                        //
                        lnRetencionLinea += (tnImporteDivisa  - lnImpPronto) * lnRetencionReter / 100;
                    }
                    else
                    {
                        // Moneda del documento es la moneda de la empresa.
                        //
                        lnImpPronto = 0.0M;
                        if (lnPrcPronto != 0)
                        {
                            lnImpPronto = tnImporte * lnPrcPronto / 100;
                            lnImpPronto +=  (lnImportePverde * lnPrcPronto / 100);
                        }

                        lnRetencionLinea += (tnImporte + lnImportePverde - lnImpPronto) * lnRetencionReter / 100;
                    }
                }
                else
                {
                    // RETENCION SOBRE TOTAL FACTURA.
                    //

                    if (ll_Divisa)
                    {
                        // Moneda del documento diferente de la de la empresa.
                        //
                        lnImpPronto = 0.0M;
                        if (lnPrcPronto != 0)
                            lnImpPronto = tnImporteDivisaIva * lnPrcPronto / 100;

                        // En divisa diferente de la moneda de la empresa no hay punto verde.
                        //
                        lnRetencionLinea += (tnImporteDivisaIva - lnImpPronto) * lnRetencionReter / 100;
                    }
                    else
                    {
                        // Moneda del documento es la moneda de la empresa.
                        //
                        lnImpPronto = 0.0M;
                        if (lnPrcPronto != 0)
                            lnImpPronto = tnImporteIva * lnPrcPronto / 100;

                        lnImportePVerdeIVA = 0.0M;

                        if (this._lPverde && lnImportePverde != 0 && !string.IsNullOrWhiteSpace(tcArticulo) && !string.IsNullOrWhiteSpace(tcTipoIva) && !string.IsNullOrWhiteSpace(lcCliente))
                        {
                            // Task 131967, optimización no utilizaré el objeto de tipos de iva sino que utilizaré el diccionario propio de tipos de IVA del documento.
                            // loTipoIva._Codigo = tcTipoIva_Pverde;
                            // lnPrcIvaPverde = loTipoIva._IVA;
                            // lnPrcIvaPverde += (tlRecEquivCliente && (this._lRecivainc || toDocumento._Cabecera._IvaInc == false)) ? Convert.ToDecimal(loTipoIva._Campo("recarg")) : 0.0M;

                            lnPrcIvaPverde = toDocumento._Informacion_Tipo_Iva(tcTipoIva_Pverde)["iva"];
                            lnPrcIvaPverde += (tlRecEquivCliente && (this._lRecivainc || toDocumento._Cabecera._IvaInc == false)) ? Convert.ToDecimal(toDocumento._Informacion_Tipo_Iva(tcTipoIva_Pverde)["recarg"]) : 0.0M;
                            
                            lnImportePVerdeIVA = (lnImportePverde * (1 + lnPrcIvaPverde / 100));

                            if (lnPrcPronto != 0)
                                lnImpPronto = lnImpPronto + (lnImportePVerdeIVA * lnPrcPronto / 100);
                        }
                        lnRetencionLinea += (tnImporteIva + lnImportePVerdeIVA - lnImpPronto) * lnRetencionReter / 100;
                    }

                    if (llRecargoReter)
                    {
                        // Si se ha de aplicar la retención también sobre el recargo de equivalencia.
                        //

                        // Task 131967, optimización no utilizaré el objeto de tipos de iva sino que utilizaré el diccionario propio de tipos de IVA del documento.
                        // loTipoIva._Codigo = lcTipo_Iva;
                        // lnRecarreg = loTipoIva._Recargo;
                        lnRecarreg = toDocumento._Informacion_Tipo_Iva(lcTipo_Iva)["recarg"];
                        
                        if (lnRecarreg != 0)
                        {
                            // Si el documento se hizo con precios SIN IVA, los campos PRECIOIVA, PRECIOIVADIV, IMPORTEIVA, IMPORTEIVADIV ya tiene el PRECIO+IVA+RECARGO
                            // Si el documento se hizo con precios CON IVA y tenemos activado el OPCFLAG de recargo equivalencia incluido en precios IVA INCLUIDO 
                            // los campos PRECIOIVA, PRECIOIVADIV, IMPORTEIVA, IMPORTEIVADIV ya tiene el PRECIO+IVA+RECARGO, SINO SON SOLO PRECIO+IVA
                            
                            // En estos dos casos no hace falta calcular la retencion de la parte de recargo de equivalencia de la linea pues ya se hizo más arriba al estar
                            // incluido el recargo en el PRECIOIVA,IMPORTEIVA.
                            
                            // Esto es solo para el caso de retención sobre total factura.
                            
                            // Si estamos en una linea de PORTES entonces sí que hay que calcular la retención del recargo pues en los portes cuando son IVA INCLUIDO
                            // siempre se entiende que no hay recargo de equivalencia incluido y hay que añadirlo
                            if (tlLineaPortes == false && (toDocumento._Cabecera._IvaInc == false || (toDocumento._Cabecera._IvaInc == true && this._lRecivainc)))
                            {

                            }
                            else
                            {
                                if (ll_Divisa)
                                {
                                    // Moneda del documento diferente de la de la empresa
                                    lnImpPronto = 0.0M;
                                    if (lnPrcPronto != 0)
                                        lnImpPronto = tnImporteDivisa * lnPrcPronto / 100;

                                    lnRetencionLinea += (tnImporteDivisa - lnImpPronto) * lnRecarreg / 100 * lnRetencionReter / 100;
                                }
                                else
                                {
                                    lnImpPronto = 0.0M;
                                    if (lnPrcPronto != 0)
                                        lnImpPronto = tnImporte * lnPrcPronto / 100;

                                    // lnRetencionLinea += (tnImporte + lnImportePverde - lnImpPronto) * lnRecarreg / 100 * lnRetencionReter / 100;
                                    lnRetencionLinea += (tnImporte - lnImpPronto) * lnRecarreg / 100 * lnRetencionReter / 100;

                                    if (this._lPverde && lnImportePverde != 0)
                                    {
                                        // Task 131967, optimización no utilizaré el objeto de tipos de iva sino que utilizaré el diccionario propio de tipos de IVA del documento.
                                        //loTipoIva._Codigo = tcTipoIva_Pverde;
                                        //lnRecarreg = loTipoIva._Recargo;
                                        lnRecarreg = toDocumento._Informacion_Tipo_Iva(tcTipoIva_Pverde)["recarg"]; ;

                                        lnImpPronto = 0.0M;
                                        if (lnPrcPronto != 0)
                                            lnImpPronto = (lnImportePverde * lnPrcPronto / 100);

                                        lnRetencionLinea += (lnImportePverde - lnImpPronto) * lnRecarreg / 100 * lnRetencionReter / 100;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return lnRetencionLinea;
        }


        private Dictionary<string, object> Obtener_Condiciones_Retencion(dynamic toDocumento)
        {
            bool llEsFactura = false, llRecargo = false;
            string lcNumFra = "",  lcTipo_Iva = "";
            DataTable ldtRetSopor = null, ldtReter = null;
            Dictionary<string, object> loDicCurReter = new Dictionary<string, object>();

            string lcEmpresa = toDocumento._Empresa;
            string lcCliente = toDocumento._Cabecera._oCliente._Codigo;

            if (string.IsNullOrWhiteSpace(lcEmpresa) || string.IsNullOrWhiteSpace(lcCliente))
                return loDicCurReter;

            // Miramos si hay que aplicar Retención FISCAL
            //
            // Recordar que a pesar de que a partir de Octubre del 2020 el % de retención fiscal viene en un campo del pie del documento
            // hemos de hacer esta consulta para averiguar si la retención es sobre base o sobre total, asi como verificar que la retención
            // en la empresa esté activa, y ninguna de las dos cosas anteriores se guarda en el documento.
            //
            // Llamamos a esté método que mira un diccionario cache interno que hemos implementado para cachear la consulta por empresa,proveedor
            // en la optimización realizada en la Task 171939
            ldtReter = this._Informacion_RetEmpCli(lcEmpresa, lcCliente);
            if (ldtReter.Rows.Count > 0)
                _lHayRetencion = true;

            // Reviso si estamos en una factura
            if ((toDocumento._TipoDocumento == eTipoDocumento.Factura ||
                 toDocumento._TipoDocumento == eTipoDocumento.FacturaVenta ||
                 toDocumento._TipoDocumento == eTipoDocumento.AlbaranVenta) &&
                 !string.IsNullOrWhiteSpace(toDocumento._Cabecera._Factura) && !string.IsNullOrWhiteSpace(toDocumento._Asi))
            {
                // Tanto si se trabaja con series de facturas como si no, en este campo tenemos el nº de factura correcto.
                llEsFactura = true;
                lcNumFra = toDocumento._Cabecera._Factura;
            }

            // Si es una factura o albarán facturado obtenemos los datos del registro de RETSOPOR
            if (llEsFactura)
            {
                ldtRetSopor = this._Informacion_RetSoporFact(toDocumento, lcNumFra);
                if (ldtReter.Rows.Count == 0)
                {
                    DataRow loRow = ldtReter.NewRow();
                    loRow["recargo"] = false;
                    loRow["tipo_iva"] = "";
                    ldtReter.Rows.Add(loRow);
                }
                ldtReter.Rows[0]["retencion"] = ldtRetSopor.Rows.Count > 0 ? Convert.ToDecimal(ldtRetSopor.Rows[0]["tipo_ret"]) : 0.0M;
                ldtReter.Rows[0]["modo_ret"] = ldtRetSopor.Rows.Count > 0 ? (Convert.ToInt32(ldtRetSopor.Rows[0]["modo_ret"]) == 1 ? true : false) : false;

                Dictionary<string, object> loDicIvareper = this._Informacion_IvareperFact(lcEmpresa, lcNumFra);
                lcTipo_Iva = Convert.ToString(loDicIvareper["tipo_iva"]);
                llRecargo = Convert.ToDecimal(loDicIvareper["recargo"]) != 0.0M;
            }

            if (ldtReter.Rows.Count == 0)
                // Esto pasará si no se detecta retencion en la ficha del cliente ni esté facturado.
                return loDicCurReter;

            if (string.IsNullOrWhiteSpace(lcTipo_Iva))
            {
                // Task 131967, optimización, aprovecho el objeto cliente de la cabecera del documento en vez de crear uno nuevo y me ahorro unas consultas
                // Cliente loCliente = new Cliente(lcCliente);
                Cliente loCliente = toDocumento._Cabecera._oCliente;
                lcTipo_Iva = loCliente._TipoIVA;
                llRecargo = loCliente._Recargo;
            }

            ldtReter.Rows[0]["tipo_iva"] = lcTipo_Iva;
            ldtReter.Rows[0]["recargo"] = llRecargo;

            // Task 170566.
            // Si no estamos en una factura el % de retención fiscal sale del pie del propio documento, la resta de condiciones por el mismo procedimiento
            // que se ha hecho hasta ahora. Cogemos la retención de la propiedad _RetencionPorcen que es la que enlaza con el campo PORCEN_RET de C_ALBVEN
            // o C_PEDIVE, C_PRESUV, etc.) que guarda el % de retención fiscal por documento. No confundir con la propiedad _RetencionDocPorcen (de solo
            // lectura, campo informativo) que devuelve el % de retención aplicado en el documento, ya sea fiscal o no fiscal.
            //
            if (!llEsFactura)
            {
                ldtReter.Rows[0]["retencion"] = toDocumento._Pie._RetencionPorcen;

                if ( toDocumento._TipoDocumento != eTipoDocumento.PedidoVenta &&
                     toDocumento._TipoDocumento != eTipoDocumento.PresupuestoVenta &&
                     toDocumento._TipoDocumento != eTipoDocumento.DepositoVenta)
                {
                    // Albarán de venta pendiente de facturar o factura de venta no contabilizada el modo de calculo de la retención (sobre base/sobre total) se 
                    // extrae del pie del documento al igual que el % de retencion. En pedidos, prespuestos y depósito hereda siempre la que hay en la ficha del 
                    // cliente. Y en factura de venta contabilizada el % y el modo cálculo se extrae de tabla GESTION!RETSOPOR
                    //
                    ldtReter.Rows[0]["modo_ret"] = (Convert.ToInt32(toDocumento._Pie._RetencionModo) == 1);    // Si es sobre base tiene .T., sobre total .F., como en la ficha cliente.
                }
            }



            loDicCurReter.Add("retencion", Convert.ToDecimal(ldtReter.Rows[0]["retencion"]));
            loDicCurReter.Add("modo_ret", Convert.ToBoolean(ldtReter.Rows[0]["modo_ret"]));
            loDicCurReter.Add("tipo_iva", lcTipo_Iva);
            loDicCurReter.Add("recargo", llRecargo);

            return loDicCurReter;
        }


        #endregion MÉTODOS PRIVADOS
    }
}